/* Minification failed. Returning unminified contents.
(4020,94-95): run-time error JS1003: Expected ':': }
(4020,98-99): run-time error JS1195: Expected expression: >
(4020,117-118): run-time error JS1004: Expected ';': )
(4023,13-14): run-time error JS1002: Syntax error: }
(4036,13-14): run-time error JS1002: Syntax error: }
(4057,43-44): run-time error JS1004: Expected ';': {
(4185,5-6): run-time error JS1002: Syntax error: }
(4188,17-18): run-time error JS1004: Expected ';': {
(4275,2-3): run-time error JS1195: Expected expression: )
(4275,19-24): run-time error JS1197: Too many errors. The file might not be a JavaScript file: 'app'
*/
(function () {
'use strict';
angular.module('common.core', ['ngRoute', 'ngCookies', 'base64', 'angularFileUpload', 'angularValidator', 'angucomplete-alt']);
})();;
(function () {
'use strict';
angular.module('common.ui', ['ui.bootstrap', 'chieffancypants.loadingBar', 'ngTable', 'ngAnimate', 'ngMask']);
})();;
(function () {
'use strict';
angular.module('common.social', ['720kb.socialshare']);
})();;
(function () {
'use strict';
angular.module("common.filters", [])
.filter('makeUppercase', function () {
return function (item) {
return item.toUpperCase();
};
})
.filter('urlEncode', function () {
return function (item) {
var encoded = item;
encoded = encoded.replace(/\//g, ' '); //replaces forward slashes with spaces
encoded = encoded.replace(/\\/g, ' '); //replaces back slashes with spaces
encoded = encoded.replace(/-/g, ' '); //replaces dashes with spaces
encoded = encoded.replace(/[^\w\s]/gi, ''); //removes all other special chars except for spaces
encoded = encoded.replace(/ +(?= )/g, ''); //removes double spaces
encoded = encoded.replace(/\s/g, '-'); //replaces all spaces with dashes
encoded = encoded.toLowerCase(); //lower case
encoded = encodeURIComponent(encoded); //url encode
return encoded;
};
})
.filter('alphaNumeric', function () {
return function (item) {
var encoded = item;
encoded = encoded.replace(/[^\w\s]/gi, ''); //removes all other special chars except for spaces
return encoded;
};
})
.filter('sqlToJsDate', function () {
return function (item) {
var date = new Date(item.replace("T", " "));
return date.getFullYear() + "/" + date.getMonth() + "/" + date.getDay();
};
})
.filter('lineBreaks', function () {
return function (item) {
return item.replace(/\n/g, "
");
};
})
.filter('percentage', ['$filter', function ($filter) {
return function (item, decimals) {
return $filter('number')(item * 100, decimals) + '%';
};
}])
.filter('btcToUsd', ['$filter', function ($filter) {
return function (btc, spotPrice) {
var conversionRate = 0.03; //3% conversion rate
var convertedSpotPrice = roundUp(spotPrice + (spotPrice * conversionRate), 0);
return roundMultiplier(roundUp(btc * convertedSpotPrice, 0), 25); //round to nearest $25
};
}])
.filter('usdToBtc', ['$filter', function ($filter) {
return function (usd, spotPrice) {
var conversionRate = 1;//0.03; //3% conversion rate
var convertedSpotPrice = roundUp(spotPrice + (spotPrice * conversionRate), 0);
return roundUp(usd / convertedSpotPrice, 4);
};
}])
.filter('numberMonth', function () {
return function (item) {
if (item == 1) return 'January';
else if (item == 2) return 'Febuary';
else if (item == 3) return 'March';
else if (item == 4) return 'April';
else if (item == 5) return 'May';
else if (item == 6) return 'June';
else if (item == 7) return 'July';
else if (item == 8) return 'August';
else if (item == 9) return 'September';
else if (item == 10) return 'October';
else if (item == 11) return 'November';
else if (item == 12) return 'December';
};
})
.filter('thumb', function () {
return function (item) {
if (item != null && item != "") {
item = item.replace('.jpg', '.thumb.jpg');
item = item.replace('.jpeg', '.thumb.jpg');
return item;
}
};
})
.filter('countryLong', function () {
return function (abbreviation) {
if (abbreviation != null) {
var found = null;
var country_names = {
'Afghanistan': 'AF', 'Albania': 'AL', 'Algeria': 'DZ', 'American Samoa': 'AS', 'Andorra': 'AD', 'Angola': 'AO', 'Anguilla': 'AI', 'Antarctica': 'AQ',
'Antigua and Barbuda': 'AG', 'Argentina': 'AR', 'Armenia': 'AM', 'Aruba': 'AW', 'Australia': 'AU', 'Austria': 'AT', 'Azerbaijan': 'AZ', 'Bahamas': 'BS',
'Bahrain': 'BH', 'Bangladesh': 'BD', 'Barbados': 'BB', 'Belarus': 'BY', 'Belgium': 'BE', 'Belize': 'BZ', 'Benin': 'BJ', 'Bermuda': 'BM', 'Bhutan': 'BT',
'Bolivia, Plurinational State of': 'BO', 'Bonaire, Sint Eustatius and Saba': 'BQ', 'Bosnia and Herzegovina': 'BA', 'Botswana': 'BW', 'Bouvet Island': 'BV',
'Brazil': 'BR', 'British Indian Ocean Territory': 'IO', 'Brunei Darussalam': 'BN', 'Bulgaria': 'BG', 'Burkina Faso': 'BF', 'Burundi': 'BI', 'Cambodia': 'KH',
'Cameroon': 'CM', 'Canada': 'CA', 'Cape Verde': 'CV', 'Cayman Islands': 'KY', 'Central African Republic': 'CF', 'Chad': 'TD', 'Chile': 'CL', 'China': 'CN',
'Christmas Island': 'CX', 'Cocos (Keeling) Islands': 'CC', 'Colombia': 'CO', 'Comoros': 'KM', 'Congo': 'CG', 'Congo, the Democratic Republic of the': 'CD',
'Cook Islands': 'CK', 'Costa Rica': 'CR', 'Croatia': 'HR', 'Cuba': 'CU', 'Curaçao': 'CW', 'Cyprus': 'CY', 'Czech Republic': 'CZ', "Côte d'Ivoire": 'CI',
'Denmark': 'DK', 'Djibouti': 'DJ', 'Dominica': 'DM', 'Dominican Republic': 'DO', 'Ecuador': 'EC', 'Egypt': 'EG', 'El Salvador': 'SV', 'Equatorial Guinea': 'GQ',
'Eritrea': 'ER', 'Estonia': 'EE', 'Ethiopia': 'ET', 'Falkland Islands (Malvinas)': 'FK', 'Faroe Islands': 'FO', 'Fiji': 'FJ', 'Finland': 'FI', 'France': 'FR',
'French Guiana': 'GF', 'French Polynesia': 'PF', 'French Southern Territories': 'TF', 'Gabon': 'GA', 'Gambia': 'GM', 'Georgia': 'GE', 'Germany': 'DE',
'Ghana': 'GH', 'Gibraltar': 'GI', 'Greece': 'GR', 'Greenland': 'GL', 'Grenada': 'GD', 'Guadeloupe': 'GP', 'Guam': 'GU', 'Guatemala': 'GT', 'Guernsey': 'GG',
'Guinea': 'GN', 'Guinea-Bissau': 'GW', 'Guyana': 'GY', 'Haiti': 'HT', 'Heard Island and McDonald Islands': 'HM', 'Holy See (Vatican City State)': 'VA',
'Honduras': 'HN', 'Hong Kong': 'HK', 'Hungary': 'HU', 'Iceland': 'IS', 'India': 'IN', 'Indonesia': 'ID', 'Iran, Islamic Republic of': 'IR', 'Iraq': 'IQ',
'Ireland': 'IE', 'Isle of Man': 'IM', 'Israel': 'IL', 'Italy': 'IT', 'Jamaica': 'JM', 'Japan': 'JP', 'Jersey': 'JE', 'Jordan': 'JO', 'Kazakhstan': 'KZ',
'Kenya': 'KE', 'Kiribati': 'KI', "Korea, Democratic People's Republic of": 'KP', 'Korea, Republic of': 'KR', 'Kuwait': 'KW', 'Kyrgyzstan': 'KG',
"Lao People's Democratic Republic": 'LA', 'Latvia': 'LV', 'Lebanon': 'LB', 'Lesotho': 'LS', 'Liberia': 'LR', 'Libya': 'LY', 'Liechtenstein': 'LI',
'Lithuania': 'LT', 'Luxembourg': 'LU', 'Macao': 'MO', 'Macedonia, the former Yugoslav Republic of': 'MK', 'Madagascar': 'MG', 'Malawi': 'MW',
'Malaysia': 'MY', 'Maldives': 'MV', 'Mali': 'ML', 'Malta': 'MT', 'Marshall Islands': 'MH', 'Martinique': 'MQ', 'Mauritania': 'MR', 'Mauritius': 'MU',
'Mayotte': 'YT', 'Mexico': 'MX', 'Micronesia, Federated States of': 'FM', 'Moldova, Republic of': 'MD', 'Monaco': 'MC', 'Mongolia': 'MN', 'Montenegro': 'ME',
'Montserrat': 'MS', 'Morocco': 'MA', 'Mozambique': 'MZ', 'Myanmar': 'MM', 'Namibia': 'NA', 'Nauru': 'NR', 'Nepal': 'NP', 'Netherlands': 'NL', 'New Caledonia': 'NC',
'New Zealand': 'NZ', 'Nicaragua': 'NI', 'Niger': 'NE', 'Nigeria': 'NG', 'Niue': 'NU', 'Norfolk Island': 'NF', 'Northern Mariana Islands': 'MP', 'Norway': 'NO',
'Oman': 'OM', 'Pakistan': 'PK', 'Palau': 'PW', 'Palestine, State of': 'PS', 'Panama': 'PA', 'Papua New Guinea': 'PG', 'Paraguay': 'PY', 'Peru': 'PE',
'Philippines': 'PH', 'Pitcairn': 'PN', 'Poland': 'PL', 'Portugal': 'PT', 'Puerto Rico': 'PR', 'Qatar': 'QA', 'Romania': 'RO', 'Russian Federation': 'RU',
'Rwanda': 'RW', 'Réunion': 'RE', 'Saint Barthélemy': 'BL', 'Saint Helena, Ascension and Tristan da Cunha': 'SH', 'Saint Kitts and Nevis': 'KN', 'Saint Lucia': 'LC',
'Saint Martin (French part)': 'MF', 'Saint Pierre and Miquelon': 'PM', 'Saint Vincent and the Grenadines': 'VC', 'Samoa': 'WS', 'San Marino': 'SM',
'Sao Tome and Principe': 'ST', 'Saudi Arabia': 'SA', 'Senegal': 'SN', 'Serbia': 'RS', 'Seychelles': 'SC', 'Sierra Leone': 'SL', 'Singapore': 'SG',
'Sint Maarten (Dutch part)': 'SX', 'Slovakia': 'SK', 'Slovenia': 'SI', 'Solomon Islands': 'SB', 'Somalia': 'SO', 'South Africa': 'ZA',
'South Georgia and the South Sandwich Islands': 'GS', 'South Sudan': 'SS', 'Spain': 'ES', 'Sri Lanka': 'LK', 'Sudan': 'SD', 'Suriname': 'SR',
'Svalbard and Jan Mayen': 'SJ', 'Swaziland': 'SZ', 'Sweden': 'SE', 'Switzerland': 'CH', 'Syrian Arab Republic': 'SY', 'Taiwan, Province of China': 'TW',
'Tajikistan': 'TJ', 'Tanzania, United Republic of': 'TZ', 'Thailand': 'TH', 'Timor-Leste': 'TL', 'Togo': 'TG', 'Tokelau': 'TK', 'Tonga': 'TO', 'Trinidad and Tobago': 'TT',
'Tunisia': 'TN', 'Turkey': 'TR', 'Turkmenistan': 'TM', 'Turks and Caicos Islands': 'TC', 'Tuvalu': 'TV', 'Uganda': 'UG', 'Ukraine': 'UA', 'United Arab Emirates': 'AE',
'United Kingdom': 'GB', 'United States': 'US', 'United States Minor Outlying Islands': 'UM', 'Uruguay': 'UY', 'Uzbekistan': 'UZ', 'Vanuatu': 'VU',
'Venezuela, Bolivarian Republic of': 'VE', 'Viet Nam': 'VN', 'Virgin Islands, British': 'VG', 'Virgin Islands, U.S.': 'VI', 'Wallis and Futuna': 'WF',
'Western Sahara': 'EH', 'Yemen': 'YE', 'Zambia': 'ZM', 'Zimbabwe': 'ZW', 'Åland Islands': 'AX'
}
for (var prop in country_names) {
if (country_names[prop] == abbreviation.toUpperCase()) {
found = prop;
}
}
return found;
}
};
});
})();;
(function () {
'use strict';
angular.module("app.filters", [])
.filter('showStatus', function () {
return function (input) {
switch (input) {
case 1:
return 'Enabled';
case 2:
return 'Disabled';
default:
return 'Disabled';
}
};
})
})();;
jQuery(function ($) {
'use strict';
// -------------------------------------------------------------
// Magnific Popup
// -------------------------------------------------------------
(function() {
$('.image-link').magnificPopup({
type: 'image',
gallery:{
enabled:true,
}
});
}());
// -------------------------------------------------------------
// Sticky Nav
// -------------------------------------------------------------
(function () {
$(window).scroll(function () {
handleTopNavAnimation();
});
$(window).load(function () {
handleTopNavAnimation();
});
}());
});
// -------------------------------------------------------------
// Utility
// -------------------------------------------------------------
var topOffSet = 40;
function scrollToTop() {
$('html, body').animate({ scrollTop: $('div.page').offset().top }, 300);
}
function scrollToSchedule() {
if (window.location.pathname !== "/") {
window.location.href = "/";
setTimeout(function () {
$('html, body').animate({ scrollTop: $('#schedule').offset().top - topOffSet }, 300);
}, 250);
}
else {
$('html, body').animate({ scrollTop: $('#schedule').offset().top - topOffSet }, 300);
}
}
function scrollToFullSchedule() {
$('html, body').animate({ scrollTop: $('#fullschedule').offset().top - topOffSet }, 300);
}
function scrollToAbout() {
$('html, body').animate({ scrollTop: $('#about').offset().top - topOffSet }, 300);
}
function scrollToAbout2() {
$('html, body').animate({ scrollTop: $('#about2').offset().top - topOffSet }, 300);
}
function scrollToRegistration() {
$('html, body').animate({ scrollTop: $('#registration').offset().top - topOffSet }, 300);
}
function scrollToBooking() {
$('html, body').animate({ scrollTop: $('#booking').offset().top - topOffSet }, 300);
}
function scrollToFeatures() {
$('html, body').animate({ scrollTop: $('#features').offset().top - topOffSet }, 300);
}
function scrollToFaq() {
$('html, body').animate({ scrollTop: $('#faq').offset().top - topOffSet }, 300);
}
function scrollToWorkshops() {
setTimeout(function () {
$('html, body').animate({ scrollTop: $('#workshops').offset().top - topOffSet }, 300);
}, 200);
}
function scrollToIntro() {
setTimeout(function () {
$('html, body').animate({ scrollTop: $('#intro').offset().top - topOffSet }, 300);
}, 200);
}
function scrollToAgenda() {
$('html, body').animate({ scrollTop: $('#agenda').offset().top - topOffSet }, 300);
}
function scrollToPricing() {
$('html, body').animate({ scrollTop: $('#pricing').offset().top - topOffSet }, 300);
}
function scrollToDiv(div) {
$('html, body').animate({ scrollTop: $(div).offset().top - topOffSet }, 300);
}
function scrollToDiv(div, offSet) {
$('html, body').animate({ scrollTop: $(div).offset().top - offSet }, 300);
}
function handleTopNavAnimation() {
var top = $(window).scrollTop();
if (top > 10) {
$('#site-nav').addClass('navbar-solid');
}
else {
$('#site-nav').removeClass('navbar-solid');
}
}
//Custom button for summernote editor
var ImageButton = function (context) {
var ui = $.summernote.ui;
// create button
var button = ui.button({
contents: '',
tooltip: 'Insert Image',
click: function () {
context.invoke('editor.saveRange'); // save cursor location
$('#mediaManagerModal').modal('show');
}
});
return button.render(); // return button as jquery object
}
var FileButton = function (context) {
var ui = $.summernote.ui;
// create button
var button = ui.button({
contents: '',
tooltip: 'Insert File',
click: function () {
context.invoke('editor.saveRange'); // save cursor location
$('#fileManagerModal').modal('show');
}
});
return button.render(); // return button as jquery object
};
//Custom button for summernote editor
var SaveBlogButtonEdit = function (context) {
var ui = $.summernote.ui;
// create button
var button = ui.button({
contents: '',
tooltip: 'Save Blog Post',
click: function () {
context.invoke('editor.saveRange'); // save cursor location
angular.element('#editBlogCtrl').scope().savePost(); // invoke angular method
}
});
return button.render(); // return button as jquery object
};
//Custom button for summernote editor
var SaveBlogButtonAdd = function (context) {
var ui = $.summernote.ui;
// create button
var button = ui.button({
contents: '',
tooltip: 'Create Blog Post',
click: function () {
context.invoke('editor.saveRange'); // save cursor location
angular.element('#addBlogCtrl').scope().savePost(); // invoke angular method
}
});
return button.render(); // return button as jquery object
};
//Custom button for summernote editor
var SaveEmailButtonAdd = function (context) {
var ui = $.summernote.ui;
// create button
var button = ui.button({
contents: '',
tooltip: 'Create Campaign Email',
click: function () {
context.invoke('editor.saveRange'); // save cursor location
angular.element('#addCampaignEmailCtrl').scope().savePost(); // invoke angular method
}
});
return button.render(); // return button as jquery object
};
//Custom button for summernote editor
var SaveEmailButtonEdit = function (context) {
var ui = $.summernote.ui;
// create button
var button = ui.button({
contents: '',
tooltip: 'Save Campaign Email',
click: function () {
context.invoke('editor.saveRange'); // save cursor location
angular.element('#editCampaignEmailCtrl').scope().savePost(); // invoke angular method
}
});
return button.render(); // return button as jquery object
};
//Generic methods for pages with summernote editor
function confirmExit() {
return "You have attempted to leave this page. Are you sure?";
}
function prevent() {
window.onbeforeunload = confirmExit;
}
function getUrlParameter(search_param) {
var sPageURL = window.location.search.substring(1);
var sURLVariables = sPageURL.split('&');
for (var i = 0; i < sURLVariables.length; i++) {
var sParameterName = sURLVariables[i].split('=');
if (sParameterName[0] == search_param) {
return sParameterName[1];
}
}
}
function checkIfDebug() {
if (location.hostname === "localhost" || location.hostname === "127.0.0.1")
return true;
else return false;
}
function attachLinks() {
$("#affiliates a").click(function (e) {
e.preventDefault();
sessionStorage.setItem('affiliateURL', $(this).attr('href'));
if (typeof $(this).attr('global-href') != "undefined") sessionStorage.setItem('affiliateGlobalURL', $(this).attr('global-href'))
else sessionStorage.removeItem('affiliateGlobalURL');
window.location.href = '/affiliates/redirect';
});
}
function loadMasks() {
$('.no-spaces').keyup(function (e) {
if (e.which === 32) {
var str = $(this).val();
str = str.replace(/\s/g, '');
$(this).val(str);
}
}).blur(function () {
var str = $(this).val();
str = str.replace(/\s/g, '');
$(this).val(str);
});
}
function roundUp(num, precision) {
precision = Math.pow(10, precision)
return Math.ceil(num * precision) / precision
}
function roundMultiplier(num, multiplier) {
multiplier = multiplier || 1;
return Math.round(num / multiplier) * multiplier;
}
function submitForm(form) {
//get the form element's document to create the input control with
//(this way will work across windows in IE8)
var button = form.ownerDocument.createElement('input');
//make sure it can't be seen/disrupts layout (even momentarily)
button.style.display = 'none';
//make it such that it will invoke submit if clicked
button.type = 'submit';
//append it and click it
form.appendChild(button).click();
//if it was prevented, make sure we don't get a build up of buttons
form.removeChild(button);
}
;
(function () {
'use strict';
var app = angular.module('app', ['common.core', 'common.ui', 'common.social', 'common.filters', 'app.filters', 'angular.filter', 'angular-cache', 'ngMeta'])
.config(config)
.run(run);
config.$inject = ['$routeProvider', '$locationProvider', 'CacheFactoryProvider', 'ngMetaProvider'];
function config($routeProvider, $locationProvider, CacheFactoryProvider, ngMetaProvider) {
angular.extend(CacheFactoryProvider.defaults, { maxAge: 15 * 60 * 1000 }); //15 min
//more info about cacheing factory: https://github.com/jmdobry/angular-cache#using-angular-cache-with-http
ngMetaProvider.useTitleSuffix(true);
ngMetaProvider.setDefaultTitle('');
ngMetaProvider.setDefaultTitleSuffix(' | Unconfiscatable Conference');
ngMetaProvider.setDefaultTag('description', 'Unconfiscatable Conference');
ngMetaProvider.setDefaultTag('keywords', 'Unconfiscatable');
ngMetaProvider.setDefaultTag('image', 'https://unconfiscatable.com/Content/images/conferences/unconfiscatable/2022/logo.png');
ngMetaProvider.setDefaultTag('twittersite', '@Unconfiscatable');
$routeProvider
//**Default************************************************
.when("/", {
templateUrl: "scripts/app/home/index.html",
controller: "indexCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Home' } }
})
//**Front End************************************************
.when("/cart", {
templateUrl: "scripts/app/cart/cart.html",
controller: "cartCtrl",
controllerAs: 'vm',
data: { meta: { 'title': 'Cart' } }
})
.when("/login", {
templateUrl: "scripts/app/account/login.html",
controller: "loginCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Login' } }
})
.when("/logout", {
templateUrl: "scripts/app/account/logout.html",
controller: "logoutCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Logout' } }
})
.when("/signin", {
templateUrl: "scripts/app/account/signin.html",
controller: "signinCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Sign-In' } }
})
.when("/signout", {
templateUrl: "scripts/app/account/signout.html",
controller: "signoutCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Sign-Out' } }
})
.when("/2019", {
templateUrl: "scripts/app/home/unconfiscatable2019.html",
controller: "unconfiscatable2019Ctrl",
controllerAs: 'vm',
})
.when("/pinball", {
templateUrl: "scripts/app/home/pinballTourney.html",
controller: "pinballTourneyCtrl",
controllerAs: 'vm',
data: { meta: { 'title': 'Pinball Tourney' } }
})
.when("/pokertourney", {
templateUrl: "scripts/app/home/pokerTourney.html",
controller: "pokerTourneyCtrl",
controllerAs: 'vm',
data: { meta: { 'title': 'Poker Tourney' } }
})
.when("/PokerHalvingParty", {
templateUrl: "scripts/app/home/poker.html",
controller: "pokerCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Poker Halving Party' } }
})
.when("/scammyawards", {
templateUrl: "scripts/app/home/scammyAwards.html",
controller: "scammyAwardsCtrl",
controllerAs: 'vm',
data: { meta: { 'title': 'Scammy Awards' } }
})
.when("/axethrowing", {
templateUrl: "scripts/app/home/axeThrowing.html",
controller: "axeThrowingCtrl",
controllerAs: 'vm',
data: { meta: { 'title': 'Axe Throwing' } }
})
.when("/testpokertourney", {
templateUrl: "scripts/app/home/test_pokerTourney.html",
controller: "test_pokerTourneyCtrl",
controllerAs: 'vm',
data: { meta: { 'title': 'Poker Tourney' } }
})
.when("/carnivory", {
templateUrl: "scripts/app/home/carnivory.html",
controller: "carnivoryCtrl",
controllerAs: 'vm',
data: { meta: { 'title': 'Carnivory Dinner' } }
})
.when("/celebrityform", {
templateUrl: "scripts/app/home/celebrityForm.html",
controller: "celebrityFormCtrl",
controllerAs: 'vm',
data: { meta: { 'title': 'Celebrity Poker Form' } }
})
.when("/contact", {
templateUrl: "scripts/app/contact/contact.html",
controller: "contactCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Contact' } }
})
.when("/media", {
templateUrl: "scripts/app/contact/mediaRequest.html",
controller: "mediaRequestCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Media Request' } }
})
//.when("/sponsors", {
// templateUrl: "scripts/app/contact/sponsorRequest.html",
// controller: "sponsorRequestCtrl",
// controllerAs: 'vm', caseInsensitiveMatch: true,
// data: { meta: { 'title': 'Sponsor Request' } }
//})
.when("/sponsorships", {
templateUrl: "scripts/app/home/sponsorships.html",
controller: "sponsorshipsCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Sponsorships' } }
})
.when("/paypal/success", {
templateUrl: "scripts/app/paypal/paypalSuccess.html",
controller: "paypalSuccessCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Payment Successful' } }
})
.when("/paypal/cancel", {
templateUrl: "scripts/app/paypal/paypalCancel.html",
controller: "paypalCancelCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Payment Canceled' } }
})
.when("/auth/:method/:customerId/:invoiceId", {
templateUrl: "scripts/app/auth/auth.html",
controller: "authCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Authenticate' } }
})
.when("/telegram", {
templateUrl: "scripts/app/telegram/telegram.html",
controller: "telegramCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Telegram Information' } }
})
.when("/telegram/request/:customerId", {
templateUrl: "scripts/app/telegram/telegramRequest.html",
controller: "telegramRequestCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Telegram Group Request' } }
})
.when("/unsubscribe/:cid/:uid", {
templateUrl: "scripts/app/unsubscribe/unsubscribe.html",
controller: "unsubscribeCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Unsubscribe' } }
})
.when("/resetpassword/:cid/:rid", {
templateUrl: "scripts/app/account/resetPassword.html",
controller: "resetPasswordCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Reset Password' } }
})
.when("/forgotpassword", {
templateUrl: "scripts/app/account/forgotPassword.html",
controller: "forgotPasswordCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Forgot Password' } }
})
//**Customer Front End************************************************
.when("/invoice/confirm/:customerId/:invoiceId", {
templateUrl: "scripts/app/invoice/confirm.html",
controller: "confirmCtrl",
controllerAs: 'vm',
data: { meta: { 'title': 'Invoice/Confirmation' } }
})
.when("/invoice/:customerId/:invoiceId", {
templateUrl: "scripts/app/invoice/invoice.html",
controller: "invoiceCtrl",
controllerAs: 'vm',
data: { meta: { 'title': 'Invoice/Payment' } },
resolve: { isAuthenticated: isAuthenticated }
})
.when("/download/:customerId/:invoiceId", {
templateUrl: "scripts/app/download/download.html",
controller: "downloadCtrl",
controllerAs: 'vm',
data: { meta: { 'title': 'Download' } },
resolve: { isAuthenticated: isAuthenticated }
})
//**Admin************************************************
.when("/admin", {
templateUrl: "scripts/app/admin/admin.html",
controller: "adminCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Admin' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/settings", {
templateUrl: "scripts/app/admin/settings/settings.html",
controller: "settingsCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Settings' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/help", {
templateUrl: "scripts/app/admin/help/help.html",
controller: "adminHelpCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Help' } },
resolve: { isAdmin: isAdmin }
})
//**Account************************************************
.when("/admin/account", {
templateUrl: "scripts/app/admin/account/editAccount.html",
controller: "editAccountCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
resolve: { isAdmin: isAdmin }
})
.when("/admin/telegram", {
templateUrl: "scripts/app/admin/telegram/telegram.html",
controller: "telegramAdminCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
resolve: { isAdmin: isAdmin }
})
//**Users************************************************
.when("/admin/users", {
templateUrl: "scripts/app/admin/users/users.html",
controller: "usersAdminCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Admins' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/users/edit/:id", {
templateUrl: "scripts/app/admin/users/editUser.html",
controller: "editUserCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Admin' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/users/add", {
templateUrl: "scripts/app/admin/users/addUser.html",
controller: "addUserCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Admin' } },
resolve: { isAdmin: isAdmin }
})
//**Discounts************************************************
.when("/admin/discounts", {
templateUrl: "scripts/app/admin/discounts/discounts.html",
controller: "discountsCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Discounts' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/discounts/edit/:id", {
templateUrl: "scripts/app/admin/discounts/editDiscount.html",
controller: "editDiscountCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Discount' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/discounts/add", {
templateUrl: "scripts/app/admin/discounts/addDiscount.html",
controller: "addDiscountCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Discount' } },
resolve: { isAdmin: isAdmin }
})
//**Payment Addresses************************************************
.when("/admin/paymentaddress", {
templateUrl: "scripts/app/admin/paymentaddress/paymentaddresses.html",
controller: "paymentAddressesCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Payment Addresses' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/paymentaddress/edit/:id", {
templateUrl: "scripts/app/admin/paymentaddress/editPaymentAddress.html",
controller: "editPaymentAddressCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Payment Address' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/paymentaddress/add", {
templateUrl: "scripts/app/admin/paymentaddress/addPaymentAddress.html",
controller: "addPaymentAddressCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Payment Address' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/paymentaddress/batchadd", {
templateUrl: "scripts/app/admin/paymentaddress/batchAddPaymentAddress.html",
controller: "batchAddPaymentAddressCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Batch Add Payment Address' } },
resolve: { isAdmin: isAdmin }
})
//**Pub Keys************************************************
.when("/admin/pubkeys", {
templateUrl: "scripts/app/admin/pubkeys/pubKeys.html",
controller: "pubKeysCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Pub Keys' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/pubkeys/edit/:id", {
templateUrl: "scripts/app/admin/pubkeys/editPubKey.html",
controller: "editPubKeyCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Pub Key' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/pubkeys/add", {
templateUrl: "scripts/app/admin/pubkeys/addPubKey.html",
controller: "addPubKeyCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Pub Key' } },
resolve: { isAdmin: isAdmin }
})
//**Customers************************************************
.when("/admin/customers", {
templateUrl: "scripts/app/admin/customers/customers.html",
controller: "customersCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Customers' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/customers/edit/:id", {
templateUrl: "scripts/app/admin/customers/editCustomer.html",
controller: "editCustomerCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Customer' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/customers/add", {
templateUrl: "scripts/app/admin/customers/addCustomer.html",
controller: "addCustomerCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Customer' } },
resolve: { isAdmin: isAdmin }
})
//**Orders************************************************
.when("/admin/orders", {
templateUrl: "scripts/app/admin/orders/orders.html",
controller: "ordersCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Orders' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/orders/edit/:id", {
templateUrl: "scripts/app/admin/orders/editOrder.html",
controller: "editOrderCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Order' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/orders/add", {
templateUrl: "scripts/app/admin/orders/addOrder.html",
controller: "addOrderCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Order' } },
resolve: { isAdmin: isAdmin }
})
//**Seminars************************************************
.when("/admin/workshop", {
templateUrl: "scripts/app/admin/seminars/seminars.html",
controller: "seminarsCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Workshops' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/ondemand", {
templateUrl: "scripts/app/admin/seminars/ondemand.html",
controller: "ondemandAdminCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'On Demand' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/workshops/edit/:id", {
templateUrl: "scripts/app/admin/seminars/editSeminar.html",
controller: "editSeminarCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Workshop' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/workshops/add", {
templateUrl: "scripts/app/admin/seminars/addSeminar.html",
controller: "addSeminarCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Workshop' } },
resolve: { isAdmin: isAdmin }
})
//**Campaigns************************************************
.when("/admin/emailcampaigns", {
templateUrl: "scripts/app/admin/emailcampaigns/emailCampaigns.html",
controller: "emailCampaignsCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Campaigns' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/emailcampaigns/edit/:id", {
templateUrl: "scripts/app/admin/emailcampaigns/editEmailCampaign.html",
controller: "editEmailCampaignCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Campaign' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/emailcampaigns/add", {
templateUrl: "scripts/app/admin/emailcampaigns/addEmailCampaign.html",
controller: "addEmailCampaignCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Campaign' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/emailcampaigns/start", {
templateUrl: "scripts/app/admin/emailcampaigns/startEmailCampaign.html",
controller: "startEmailCampaignCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Start Campaign' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/emailcampaigns/emails", {
templateUrl: "scripts/app/admin/emailcampaigns/emails/campaignEmails.html",
controller: "campaignEmailsCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Campaign Emails' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/emailcampaigns/emails/add", {
templateUrl: "scripts/app/admin/emailcampaigns/emails/addCampaignEmail.html",
controller: "addCampaignEmailCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Campaign Email' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/emailcampaigns/emails/edit/:id", {
templateUrl: "scripts/app/admin/emailcampaigns/emails/editCampaignEmail.html",
controller: "editCampaignEmailCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Campaign Email' } },
resolve: { isAdmin: isAdmin }
})
//**Events************************************************
.when("/admin/events", {
templateUrl: "scripts/app/admin/events/events.html",
controller: "eventsAdminCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Events' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/events/calendar", {
templateUrl: "scripts/app/admin/events/calendar.html",
controller: "eventCalendarCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Event Calendar' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/events/edit/:id", {
templateUrl: "scripts/app/admin/events/editEvent.html",
controller: "editEventCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Event' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/events/add/:day/:time", {
templateUrl: "scripts/app/admin/events/addEvent.html",
controller: "addEventCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Event' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/eventprices", {
templateUrl: "scripts/app/admin/events/eventPrices.html",
controller: "eventPricesCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Event Pricing' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/eventprices/edit/:id", {
templateUrl: "scripts/app/admin/events/editEventPrice.html",
controller: "editEventPriceCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Event Price' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/eventprices/add", {
templateUrl: "scripts/app/admin/events/addEventPrice.html",
controller: "addEventPriceCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Event Price' } },
resolve: { isAdmin: isAdmin }
})
//**Conferences************************************************
.when("/admin/conferences", {
templateUrl: "scripts/app/admin/conferences/conferences.html",
controller: "conferencesCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Conferences' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/conferences/edit/:id", {
templateUrl: "scripts/app/admin/conferences/editConference.html",
controller: "editConferenceCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Conference' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/conferences/add", {
templateUrl: "scripts/app/admin/conferences/addConference.html",
controller: "addConferenceCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Conference' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/conferences/products/edit/:id", {
templateUrl: "scripts/app/admin/conferences/editConferenceProduct.html",
controller: "editConferenceProductCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Conference Product' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/conferences/:id/products/add", {
templateUrl: "scripts/app/admin/conferences/addConferenceProduct.html",
controller: "addConferenceProductCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Conference Product' } },
resolve: { isAdmin: isAdmin }
})
//**Subscriptions************************************************
.when("/admin/subscriptions", {
templateUrl: "scripts/app/admin/subscriptions/subscriptions.html",
controller: "subscriptionsCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Subscriptions' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/subscriptions/edit/:id", {
templateUrl: "scripts/app/admin/subscriptions/editSubscription.html",
controller: "editSubscriptionCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Subscription' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/subscriptions/add", {
templateUrl: "scripts/app/admin/subscriptions/addSubscription.html",
controller: "addSubscriptionCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Subscription' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/subscriptions/products/edit/:id", {
templateUrl: "scripts/app/admin/subscriptions/editSubscriptionProduct.html",
controller: "editSubscriptionProductCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Subscription Product' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/subscriptions/:id/products/add", {
templateUrl: "scripts/app/admin/subscriptions/addSubscriptionProduct.html",
controller: "addSubscriptionProductCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Subscription Product' } },
resolve: { isAdmin: isAdmin }
})
//**Products************************************************
.when("/admin/products", {
templateUrl: "scripts/app/admin/products/products.html",
controller: "productsCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Products' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/products/edit/:id", {
templateUrl: "scripts/app/admin/products/editProduct.html",
controller: "editProductCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Product' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/products/add", {
templateUrl: "scripts/app/admin/products/addProduct.html",
controller: "addProductCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Product' } },
resolve: { isAdmin: isAdmin }
})
//**GalleryImages************************************************
.when("/admin/gallery", {
templateUrl: "scripts/app/admin/gallery/galleryImages.html",
controller: "galleryImagesCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Gallery Images' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/gallery/edit/:id", {
templateUrl: "scripts/app/admin/gallery/editGalleryImage.html",
controller: "editGalleryImageCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Gallery Image' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/gallery/add", {
templateUrl: "scripts/app/admin/gallery/addGalleryImage.html",
controller: "addGalleryImageCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Gallery Image' } },
resolve: { isAdmin: isAdmin }
})
//**Affiliates************************************************
.when("/admin/affiliates", {
templateUrl: "scripts/app/admin/affiliates/affiliatesAdmin.html",
controller: "affiliatesAdminCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Affiliates' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/affiliates/edit/:id", {
templateUrl: "scripts/app/admin/affiliates/editAffiliate.html",
controller: "editAffiliateCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Affiliate' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/affiliates/add", {
templateUrl: "scripts/app/admin/affiliates/addAffiliate.html",
controller: "addAffiliateCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Affiliate' } },
resolve: { isAdmin: isAdmin }
})
//**Categories************************************************
.when("/admin/categories", {
templateUrl: "scripts/app/admin/categories/categories.html",
controller: "categoriesCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Categories' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/categories/edit/:id", {
templateUrl: "scripts/app/admin/categories/editCategory.html",
controller: "editCategoryCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Category' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/categories/add", {
templateUrl: "scripts/app/admin/categories/addCategory.html",
controller: "addCategoryCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Category' } },
resolve: { isAdmin: isAdmin }
})
//**Blogs*****************************************************
.when("/admin/blogs", {
templateUrl: "scripts/app/admin/blogs/blogs.html",
controller: "blogsCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Blogs' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/blogs/featured", {
templateUrl: "scripts/app/admin/blogs/blogsFeatured.html",
controller: "blogsFeaturedCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Featured Blogs' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/blogs/edit/:id", {
templateUrl: "scripts/app/admin/blogs/editBlog.html",
controller: "editBlogCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Blog' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/blogs/add", {
templateUrl: "scripts/app/admin/blogs/addBlog.html",
controller: "addBlogCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Blog' } },
resolve: { isAdmin: isAdmin }
})
//**Workshop Help************************************************
.when("/admin/workshophelp", {
templateUrl: "scripts/app/admin/seminarhelp/adminSeminarHelp.html",
controller: "adminSeminarHelpCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Workshop Help' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/workshophelp/edit/:id", {
templateUrl: "scripts/app/admin/seminarhelp/editSeminarHelp.html",
controller: "editSeminarHelpCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Workshop Help' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/workshophelp/add", {
templateUrl: "scripts/app/admin/seminarhelp/addSeminarHelp.html",
controller: "addSeminarHelpCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Workshop Help' } },
resolve: { isAdmin: isAdmin }
})
//**Pages************************************************
.when("/admin/pages", {
templateUrl: "scripts/app/admin/pages/pages.html",
controller: "pagesCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Pages' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/pages/edit/:id", {
templateUrl: "scripts/app/admin/pages/editPage.html",
controller: "editPageCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Page' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/pages/add", {
templateUrl: "scripts/app/admin/pages/addPage.html",
controller: "addPageCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Page' } },
resolve: { isAdmin: isAdmin }
})
//**Media************************************************
.when("/admin/media", {
templateUrl: "scripts/app/admin/mediacontent/mediaContent.html",
controller: "mediaContentCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Media' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/media/add", {
templateUrl: "scripts/app/admin/mediacontent/addMediaContent.html",
controller: "addMediaContentCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Media' } },
resolve: { isAdmin: isAdmin }
})
//**Emails************************************************
.when("/admin/emails", {
templateUrl: "scripts/app/admin/emails/emails.html",
controller: "emailsCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Emails' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/emails/add", {
templateUrl: "scripts/app/admin/emails/addEmail.html",
controller: "addEmailCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Add Automated Email' } },
resolve: { isAdmin: isAdmin }
})
.when("/admin/emails/edit/:id", {
templateUrl: "scripts/app/admin/emails/editEmail.html",
controller: "editEmailCtrl",
controllerAs: 'vm', caseInsensitiveMatch: true,
data: { meta: { 'title': 'Edit Automated Email' } },
resolve: { isAdmin: isAdmin }
})
.otherwise({ redirectTo: "/" });
//Use the HTML5 History API
$locationProvider.html5Mode(true);
}
run.$inject = ['$rootScope', '$location', '$cookieStore', '$http', '$window', '$timeout', 'ngMeta'];
function run($rootScope, $location, $cookieStore, $http, $window, $timeout, ngMeta) {
// meta tags
ngMeta.init();
// send page view to google analytics
$rootScope.$on('$routeChangeStart', function ($event, next, current) {
// don't send admin pages or dashboard pages
if ($location.path().indexOf('/admin/') === -1 && $location.path().indexOf('/dashboard/') === -1) {
// don't send local pages
if ($location.absUrl().indexOf('localhost') === -1) {
$window.gtag('config', 'UA-136464593-1', { 'page_path': $location.path() });
}
}
else {
if ($location.path !== '/admin') {
//remove adminTimer
$timeout.cancel($rootScope.adminTimer);
}
}
});
// handle page refreshes
$rootScope.repository = $cookieStore.get('repository') || {};
if ($rootScope.repository.loggedUser) {
$http.defaults.headers.common['Authorization'] = $rootScope.repository.loggedUser.authdata;
}
$(document).ready(function () {
$(".fancybox").fancybox({
openEffect: 'none',
closeEffect: 'none'
});
$('.fancybox-media').fancybox({
openEffect: 'none',
closeEffect: 'none',
helpers: {
media: {}
}
});
$('[data-toggle=offcanvas]').click(function () {
$('.row-offcanvas').toggleClass('active');
});
});
}
isAdmin.$inject = ['membershipService', '$rootScope', '$location'];
function isAdmin(membershipService, $rootScope, $location) {
if (membershipService.isUserLoggedIn()) {
var role = $rootScope.repository.loggedUser.role;
if (role != 'Admin' && role != 'Editor') {
$rootScope.previousState = $location.path();
$location.path('/login');
}
}
else {
$rootScope.previousState = $location.path();
$location.path('/login');
}
}
isAuthenticated.$inject = ['membershipService', '$rootScope', '$location'];
function isAuthenticated(membershipService, $rootScope, $location) {
if (!membershipService.isUserLoggedIn()) {
$rootScope.previousState = $location.path();
$location.path('/signin');
}
}
isPortal.$inject = ['membershipService', '$rootScope', '$location'];
function isPortal(membershipService, $rootScope, $location) {
if (!membershipService.isUserLoggedIn()) {
$rootScope.previousState = $location.path();
$location.path('/signin');
}
else {
if ($rootScope.repository.loggedUser.username == 'customer') {
$rootScope.previousState = $location.path();
$location.path('/signin');
}
}
}
//Using bootstrap method https://blog.mariusschulz.com/2014/10/22/asynchronously-bootstrapping-angularjs-applications-with-server-side-data
var url = "api/sitesettings";
//commented out because this site doesn't need site settings to load
app.constant("appConfig", null);
bootstrapApplication();
////sessionStorage.removeItem(url);
//if (sessionStorage.getItem(url) === null) {
// fetchData().then(bootstrapApplication);
//}
//else {
// var data = JSON.parse(sessionStorage.getItem(url));
// app.constant("appConfig", data);
// bootstrapApplication();
//}
function fetchData() {
var initInjector = angular.injector(["ng"]);
var $http = initInjector.get("$http");
var url = "api/sitesettings";
return $http.get(url, { cache: true })
.then(function (response) {
sessionStorage.setItem(url, JSON.stringify(response.data));
app.constant("appConfig", response.data);
hideLoading();
}, function (error) {
console.log('Error getting settings.');
app.constant("appConfig", null);
showDBError();
});
}
function bootstrapApplication() {
angular.element(document).ready(function () {
hideLoading();
showApplication();
angular.bootstrap(document, ["app"]);
});
}
function hideLoading() {
setTimeout(function () {
$(".page-cover.page-loader").fadeOut('slow');
}, 200);
}
function showApplication() {
setTimeout(function () {
$('.container.top-logo, footer').css({ opacity: 0.0, visibility: "visible" }).animate({ opacity: 1 }, 'slow');
}, 200);
}
function showDBError() {
$(".page-cover.page-error").show();
$("body").css({ "overflow": 'hidden' }, { "posiiton": "relative" });
}
}());;
(function (app) {
'use strict';
app.factory('apiService', apiService);
apiService.$inject = ['$http', '$location', 'notificationService','$rootScope'];
function apiService($http, $location, notificationService, $rootScope) {
var service = {
get: get,
post: post,
put: put
};
function get(url, config, success, failure) {
return $http.get(url, config)
.then(function (result) {
success(result);
}, function (error) {
if (error.status == '401') {
notificationService.displayError('Authentication required.');
$rootScope.previousState = $location.path();
$location.path('/');
}
else if (failure != null) {
failure(error);
}
});
}
function post(url, data, success, failure) {
return $http.post(url, data)
.then(function (result) {
success(result);
}, function (error) {
if (error.status == '401') {
notificationService.displayError('Authentication required.');
$rootScope.previousState = $location.path();
$location.path('/');
}
else if (failure != null) {
failure(error);
}
});
}
function put(url, data, success, failure) {
return $http.put(url, data)
.then(function (result) {
success(result);
}, function (error) {
failure(error);
});
}
return service;
}
})(angular.module('common.core'));;
(function (app) {
'use strict';
app.factory('ordersService', ordersService);
ordersService.$inject = ['$http', '$q'];
function ordersService($http, $q) {
var service = {
getOrders: getOrders
};
function getOrders(config) {
var deferred = $q.defer();
$http.get('/api/orders', config).then(function (response) {
var data = response.data;
deferred.resolve(data);
}, function (msg, code) {
deferred.reject(msg);
});
return deferred.promise;
}
return service;
}
})(angular.module('common.core'));;
(function (app) {
'use strict';
app.factory('customersService', customersService);
customersService.$inject = ['$http', '$q'];
function customersService($http, $q) {
var service = {
getCustomers: getCustomers
};
function getCustomers(config) {
var deferred = $q.defer();
$http.get('/api/customers', config).then(function (response) {
var data = response.data;
deferred.resolve(data);
}, function (msg, code) {
deferred.reject(msg);
});
return deferred.promise;
}
return service;
}
})(angular.module('common.core'));;
(function (app) {
'use strict';
app.factory('seminarsService', seminarsService);
seminarsService.$inject = ['$http', '$q'];
function seminarsService($http, $q) {
var service = {
getSeminars: getSeminars
};
function getSeminars(config) {
var deferred = $q.defer();
$http.get('/api/seminars', config).then(function (response) {
var data = response.data;
deferred.resolve(data);
}, function (msg, code) {
deferred.reject(msg);
});
return deferred.promise;
}
return service;
}
})(angular.module('common.core'));;
(function (app) {
'use strict';
app.factory('notificationService', notificationService);
function notificationService() {
toastr.options = {
"debug": false,
"positionClass": "toast-top-right",
"onclick": null,
"fadeIn": 300,
"fadeOut": 1000,
"timeOut": 3000,
"extendedTimeOut": 1000
};
var service = {
displaySuccess: displaySuccess,
displayError: displayError,
displayWarning: displayWarning,
displayInfo: displayInfo
};
return service;
function displaySuccess(message) {
toastr.success(message);
}
function displayError(error) {
if (Array.isArray(error)) {
error.forEach(function (err) {
toastr.error(err);
});
} else {
toastr.error(error);
}
}
function displayWarning(message) {
toastr.warning(message);
}
function displayInfo(message) {
toastr.info(message);
}
}
})(angular.module('common.core'));;
(function (app) {
'use strict';
app.factory('membershipService', membershipService);
membershipService.$inject = ['apiService', 'notificationService','$http', '$base64', '$cookieStore', '$rootScope'];
function membershipService(apiService, notificationService, $http, $base64, $cookieStore, $rootScope) {
var service = {
login: login,
register: register,
update: update,
updatePassword: updatePassword,
updatePasswordById: updatePasswordById,
updateRole: updateRole,
remove: remove,
saveCredentials: saveCredentials,
saveCustomer: saveCustomer,
removeCredentials: removeCredentials,
isUserLoggedIn: isUserLoggedIn
}
function login(user, completed) {
apiService.post('/api/account/authenticate', user,
completed,
loginFailed);
}
function register(user, completed, failed) {
apiService.post('/api/account/register', user,
completed,
failed);
}
function update(user, completed, failed) {
apiService.put('/api/account/update', user,
completed,
failed);
}
function updatePassword(user, completed, failed) {
apiService.put('/api/account/updatepassword', user,
completed,
failed);
}
function updatePasswordById(user, completed, failed) {
apiService.put('/api/account/updatepasswordbyid', user,
completed,
failed);
}
function updateRole(user, completed, failed) {
apiService.put('/api/account/updaterole', user,
completed,
failed);
}
function remove(user, completed, failed) {
apiService.post('/api/account/delete', user,
completed,
failed);
}
function saveCredentials(user) {
var membershipData = $base64.encode(user.username + ':' + user.password);
$rootScope.repository = {
loggedUser: {
username: user.username,
id: user.id,
role: user.role,
authdata: membershipData
}
};
$http.defaults.headers.common['Authorization'] = 'Basic ' + membershipData;
$cookieStore.put('repository', $rootScope.repository);
}
function saveCustomer(customer) {
$rootScope.repository.loggedCustomer = customer;
$cookieStore.put('repository', $rootScope.repository);
}
function removeCredentials() {
$rootScope.repository = {};
$cookieStore.remove('repository');
$http.defaults.headers.common.Authorization = '';
sessionStorage.removeItem('/api/customers/authenticate');
};
function loginFailed(response) {
notificationService.displayError(response.data);
}
function registrationFailed(response) {
notificationService.displayError('Registration failed. Try again.');
}
function isUserLoggedIn() {
return $rootScope.repository.loggedUser != null;
}
return service;
}
})(angular.module('common.core'));;
(function (app) {
'use strict';
app.factory('fileUploadService', fileUploadService);
fileUploadService.$inject = ['$rootScope', '$http', '$timeout', '$upload', 'notificationService'];
function fileUploadService($rootScope, $http, $timeout, $upload, notificationService) {
$rootScope.upload = [];
var service = {
uploadImage: uploadImage,
uploadMediaContentImageImage: uploadMediaContentImageImage,
uploadFile: uploadFile
}
function uploadImage($files, type, id, callback) {
//$files: an array of files selected
for (var i = 0; i < $files.length; i++) {
var $file = $files[i];
(function (index) {
$rootScope.upload[index] = $upload.upload({
url: "api/" + type + "s/images/upload?" + type + "Id=" + id, // webapi url
method: "POST",
file: $file
}).progress(function (evt) {
}).success(function (data, status, headers, config) {
// file is uploaded successfully
//notificationService.displaySuccess(data.FileName + ' uploaded successfully');
callback(data);
}).error(function (data, status, headers, config) {
notificationService.displayError(data.Message);
});
})(i);
}
}
function uploadMediaContentImageImage($files, callback) {
//$files: an array of files selected
for (var i = 0; i < $files.length; i++) {
var $file = $files[i];
(function (index) {
$rootScope.upload[index] = $upload.upload({
url: "api/mediacontent/images/upload", // webapi url
method: "POST",
file: $file
}).progress(function (evt) {
}).success(function (data, status, headers, config) {
// file is uploaded successfully
//notificationService.displaySuccess(data.FileName + ' uploaded successfully');
callback(data);
}).error(function (data, status, headers, config) {
notificationService.displayError(data.Message);
});
})(i);
}
}
function uploadFile($files, type, id, callback) {
//$files: an array of files selected
for (var i = 0; i < $files.length; i++) {
var $file = $files[i];
(function (index) {
$rootScope.upload[index] = $upload.upload({
url: "api/products/files/upload?productId=" + id, // webapi url
method: "POST",
file: $file
}).progress(function (evt) {
}).success(function (data, status, headers, config) {
// file is uploaded successfully
//notificationService.displaySuccess(data.FileName + ' uploaded successfully');
callback(data);
}).error(function (data, status, headers, config) {
notificationService.displayError(data.Message);
});
})(i);
}
}
return service;
}
})(angular.module('common.core'));;
(function (app) {
'use strict';
app.factory('youtubeService', youtubeService);
youtubeService.$inject = ['$http', 'apiService', 'notificationService', 'appConfig'];
function youtubeService($http, apiService, notificationService, appConfig) {
var key = 'AIzaSyCdT0sQK5LHDEBRBc-sqq8yEerJFYtXmnU', channelId = 'UCbiWJYRg8luWHnmNkJRZEnw';
var service = {
getChannel: getChannel,
getVideos: getVideos,
getVideosByQuery: getVideosByQuery,
getVideo: getVideo,
getPlaylistsById: getPlaylistsById,
getPlaylistsByChannel: getPlaylistsByChannel,
getPlaylistItems: getPlaylistItems,
getLiveVideos: getLiveVideos,
getPopularVideos: getPopularVideos,
getUpcomingLiveVideos: getUpcomingLiveVideos,
getLiveStatus: getLiveStatus,
};
function getChannel(config, success, failure) {
var url = "https://www.googleapis.com/youtube/v3/channels";
var params = {
part: 'snippet,contentDetails,statistics',
forUsername: 'Hyperwave',
key: key
};
config.params = params;
$.get(url, config.params, function () {/*success*/ }).done(function (data) { return success(data); }).fail(function (error) { return failure(error); });
}
function getPlaylistsById(config, success, failure) {
var url = "https://www.googleapis.com/youtube/v3/playlists";
var params = {
part: 'snippet,contentDetails',
id: config.playListsIds,
key: key
};
config.params = params;
$.get(url, config.params, function () {/*success*/ }).done(function (data) { return success(data); }).fail(function (error) { return failure(error); });
}
function getPlaylistsByChannel(config, success, failure) {
var url = "https://www.googleapis.com/youtube/v3/playlists";
var params = {
part: 'snippet,contentDetails',
channelId: channelId,
key: key
};
config.params = params;
$.get(url, config.params, function () {/*success*/ }).done(function (data) { return success(data); }).fail(function (error) { return failure(error); });
}
function getVideos(config, success, failure) {
var url = "https://www.googleapis.com/youtube/v3/search";
var params = {
part: 'snippet',
order: 'date',
channelId: channelId,
maxResults: config.pageSize,
pageToken: config.pageToken,
type: 'video',
key: key
};
config.params = params;
$.get(url, config.params, function () {/*success*/ }).done(function (data) { return success(data); }).fail(function (error) { return failure(error); });
}
function getVideosByQuery(config, success, failure) {
var url = "https://www.googleapis.com/youtube/v3/search";
var params = {
part: 'snippet',
order: 'relevance',
channelId: channelId,
maxResults: config.pageSize,
pageToken: config.pageToken,
type: 'video',
q: config.query,
key: key
};
config.params = params;
$.get(url, config.params, function () {/*success*/ }).done(function (data) { return success(data); }).fail(function (error) { return failure(error); });
}
function getVideo(config, success, failure) {
var url = "https://www.googleapis.com/youtube/v3/videos";
var params = {
part: 'snippet',
order: 'date',
id: config.id,
key: key
};
config.params = params;
$.get(url, config.params, function () {/*success*/ }).done(function (data) { return success(data); }).fail(function (error) { return failure(error); });
}
function getPopularVideos(count, config, success, failure) {
var today = new Date();
var thisYear;
//if it's january then take from the december of prev year
//otherwise get all videos from prev month to current
if (today.getMonth() === 0) {
thisYear = ISODateString(new Date(today.getFullYear() - 1, 11, 1));
}
else {
thisYear = ISODateString(new Date(today.getFullYear(), (today.getMonth() - 1), 1));
}
var url = "https://www.googleapis.com/youtube/v3/search";
var params = {
part: 'snippet',
order: 'viewCount',
channelId: channelId,
maxResults: count,
publishedAfter: thisYear,
key: key
};
if (config == null) config = {};
config.params = params;
$.get(url, config.params, function () {/*success*/ }).done(function (data) { return success(data); }).fail(function (error) { return failure(error); });
}
function getPlaylistItems(config, success, failure) {
var url = "https://www.googleapis.com/youtube/v3/playlistItems";
var params = {
part: 'snippet, contentDetails',
order: 'viewCount',
playlistId: config.playlistId,
maxResults: config.pageSize,
pageToken: config.pageToken,
key: key
};
config.params = params;
$.get(url, config.params, function () {/*success*/ }).done(function (data) { return success(data); }).fail(function (error) { return failure(error); });
}
function getUpcomingLiveVideos(config, success, failure) {
var url = "https://www.googleapis.com/youtube/v3/search";
var params = {
part: 'snippet',
channelId: channelId,
type: 'video',
eventType: 'upcoming',
key: key
};
if (typeof config != 'undefined') config = {};
config.params = params;
$.get(url, config.params, function () {/*success*/ }).done(function (data) { return success(data); }).fail(function (error) { return failure(error); });
}
function getLiveVideos(config, success, failure) {
var url = "https://www.googleapis.com/youtube/v3/search";
var params = {
part: 'snippet',
channelId: channelId,
type: 'video',
eventType: 'live',
key: key
};
if (typeof config != 'undefined') config = {};
config.params = params;
$.get(url, config.params, function () {/*success*/ }).done(function (data) { return success(data); }).fail(function (error) { return failure(error); });
}
function getLiveStatus() {
return $.get('https://www.googleapis.com/youtube/v3/liveBroadcasts', { part: 'snippet, status', channelId: channelId, broadcastStatus: 'active', key: key });
}
function ISODateString(d) {
function pad(n) { return n < 10 ? '0' + n : n }
return d.getUTCFullYear() + '-'
+ pad(d.getUTCMonth() + 1) + '-'
+ pad(d.getUTCDate()) + 'T'
+ pad(d.getUTCHours()) + ':'
+ pad(d.getUTCMinutes()) + ':'
+ pad(d.getUTCSeconds()) + 'Z'
}
return service;
}
})(angular.module('common.core'));;
(function (app) {
'use strict';
app.factory('bitcoinService', bitcoinService);
bitcoinService.$inject = ['$http', 'apiService', 'notificationService'];
function bitcoinService($http, apiService, notificationService) {
var service = {
getBTCPrice: getBTCPrice,
getTransaction: getTransaction,
getAddressTransactions: getAddressTransactions,
getTransactionOutputs: getTransactionOutputs,
getTransactionsReceived: getTransactionsReceived,
isAddressValid: isAddressValid
};
function getBTCPrice(success, failure, useCors) {
var url = '/api/orders/getbtcprice';
//if (useCors) url = "https://cors-anywhere.herokuapp.com/https://chain.so/api/v2/get_price/BTC/USD/";
//else url = "https://chain.so/api/v2/get_price/BTC/USD/";
return $http.get(url).then(function (result) { success(result); }, function (error) { if (failure != null) { failure(error); } });
}
function getTransaction(txId, success, failure, useCors) {
var url = '';
if (useCors) url = "https://cors-anywhere.herokuapp.com/https://api.bitaps.com/btc/v1/blockchain/transaction/" + txId;
else url = "https://api.bitaps.com/btc/v1/blockchain/transaction/" + txId;
return $http.get(url).then(function (result) { success(result); }, function (error) { if (failure != null) { failure(error); } });
}
function getAddressTransactions(address, success, failure, useCors) {
var url = '';
if (useCors) url = "https://cors-anywhere.herokuapp.com/https://api.bitaps.com/btc/v1/blockchain/address/transactions/" + address;
else url = "https://api.bitaps.com/btc/v1/blockchain/address/transactions/" + address;
return $http.get(url).then(function (result) { success(result); }, function (error) { if (failure != null) { failure(error); } });
}
function getTransactionOutputs(txId, success, failure, useCors) {
var url = '';
if (useCors) url = "https://cors-anywhere.herokuapp.com/https://chain.so/api/v2/get_tx_outputs/BTC/" + txId;
else url = "https://chain.so/api/v2/get_tx_outputs/BTC/" + txId;
return $http.get(url).then(function (result) { success(result); }, function (error) { if (failure != null) { failure(error); } });
}
function getTransactionsReceived(address, success, failure, useCors) {
var url = '';
if (useCors) url = "https://cors-anywhere.herokuapp.com/https://chain.so/api/v2/get_tx_received/BTC/" + address;
else url = "https://chain.so/api/v2/get_tx_received/BTC/" + address;
return $http.get(url).then(function (result) { success(result); }, function (error) { if (failure != null) { failure(error); } });
}
function isAddressValid(address, success, failure, useCors) {
var url = '';
if (useCors) url = "https://cors-anywhere.herokuapp.com/https://chain.so/api/v2/is_address_valid/BTC/" + address;
else url = "https://chain.so/api/v2/is_address_valid/BTC/" + address;
return $http.get(url).then(function (result) { success(result); }, function (error) { if (failure != null) { failure(error); } });
}
return service;
}
})(angular.module('common.core'));;
(function (app) {
'use strict';
app.controller('rootCtrl', rootCtrl);
rootCtrl.$inject = ['$scope', '$location', '$filter', 'apiService', 'notificationService', 'membershipService', 'youtubeService', 'appConfig', '$rootScope'];
function rootCtrl($scope, $location, $filter, apiService, notificationService, membershipService, youtubeService, appConfig, $rootScope) {
var vm = this;
$scope.userData = {};
$scope.loggedUser = []
$scope.loggedCustomer = [];
$scope.PageContent = [];
$scope.episodes = {};
$scope.loadLatestVideos = loadLatestVideos;
$scope.userData.displayUserInfo = displayUserInfo;
$scope.userData.displayCustomerInfo = displayCustomerInfo;
$scope.logout = logout;
$scope.signout = signout;
$scope.getPageContent = getPageContent;
vm.query = "";
vm.cacheKey = "";
vm.cacheKey2 = "";
vm.cacheKey3 = "";
vm.page = 0;
vm.pagesCount = 0;
vm.nextPageToken = "";
vm.prevPageToken = "";
vm.search = function () {
var filtered = $filter('alphaNumeric')(vm.query);
if (filtered.length > 0) {
vm.query = "";
$location.path('/search/' + filtered);
}
};
vm.enter = function (event) {
if (event.keyCode === 13) {
vm.search();
}
};
$scope.loadScript = function (url, type, charset) {
if (type === undefined) type = 'text/javascript';
if (url) {
var script = document.querySelector("script[src*='" + url + "']");
if (!script) {
var heads = document.getElementsByTagName("head");
if (heads && heads.length) {
var head = heads[0];
if (head) {
script = document.createElement('script');
script.setAttribute('src', url);
script.setAttribute('type', type);
if (charset) script.setAttribute('charset', charset);
head.appendChild(script);
}
}
}
return script;
}
};
function loadPageContent() {
//commented out because this site requires no settings to load, previous sites needed a youtube api key to load
//if (appConfig != null) {
hideLoading();
var url = '/api/pagecontent';
apiService.get(url, null,
pageContentLoadCompleted,
loadFailed
);
//vm.cacheKey = url;
////sessionStorage.removeItem(vm.cacheKey);
//if (sessionStorage.getItem(vm.cacheKey) === null) {
// apiService.get(url, null,
// pageContentLoadCompleted,
// loadFailed
// );
//}
//else {
// setTimeout(function () {
// pageContentLoadCompleted(JSON.parse(sessionStorage.getItem(vm.cacheKey)));
// }, 200);
//}
//}
//else {
// hideLoading();
// showDBError();
//}
}
function pageContentLoadCompleted(result) {
if (sessionStorage.getItem(vm.cacheKey) === null) sessionStorage.setItem(vm.cacheKey, JSON.stringify(result));
$scope.PageContent = result.data;
$rootScope.$broadcast("pageContentLoaded");
loadPageContentJS();
}
$scope.$on('forcePageContentLoad', function (event, data) {
loadPageContent();
});
$scope.$on('forceVideosLoad', function (event, data) {
loadLatestVideos();
});
function loadFailed(response) {
hideLoading();
showDBError();
}
function displayUserInfo() {
$scope.userData.isUserLoggedIn = membershipService.isUserLoggedIn();
if ($scope.userData.isUserLoggedIn)
{
$scope.loggedUser = $rootScope.repository.loggedUser;
$rootScope.$broadcast("showUserData");
}
}
function displayCustomerInfo() {
if ($scope.userData.isUserLoggedIn) {
$scope.loggedCustomer = $rootScope.repository.loggedCustomer;
$rootScope.$broadcast("showCustomerData");
}
}
function loadLatestVideos(page, direction) {
var token = "";
if (typeof direction == 'undefined' || direction == "") {
direction = (page >= vm.page) ? "next" : "prev";
}
vm.page = page || 0;
token = (direction == 'next') ? vm.nextPageToken : vm.prevPageToken;
vm.cacheKey3 = "getVideosHomepage";
//sessionStorage.removeItem(vm.cacheKey3);
if (sessionStorage.getItem(vm.cacheKey3) == null) {
var config = {
pageSize: 3,
pageToken: token
};
youtubeService.getVideos(config,
episodesLoadCompleted,
episodesLoadFailed
);
}
else {
episodesLoadCompleted(JSON.parse(sessionStorage.getItem(vm.cacheKey3)));
}
}
function episodesLoadCompleted(result) {
if (sessionStorage.getItem(vm.cacheKey3) == null) sessionStorage.setItem(vm.cacheKey3, JSON.stringify(result));
$scope.episodes = result.items;
vm.nextPageToken = result.nextPageToken;
vm.prevPageToken = result.prevPageToken;
vm.pagesCount = Math.ceil(result.pageInfo.totalResults / result.pageInfo.resultsPerPage);
vm.totalCount = result.pageInfo.totalResults
$rootScope.$broadcast("latestVideosLoaded");
}
function episodesLoadFailed(response) {
notificationService.displayError(response.data);
}
function logout() {
membershipService.removeCredentials();
window.location.href = '/';
}
function signout() {
membershipService.removeCredentials();
window.location.href = '/signin';
}
function getPageContent(title) {
for (var i = 0; i < $scope.PageContent.length; i++) {
var page = $scope.PageContent[i];
if (page.Title === title) return page;
}
}
function hideLoading() {
setTimeout(function () {
$(".page-cover.page-loader").fadeOut('slow');
$('.container.top-logo, footer').css({ opacity: 0.0, visibility: "visible" }).animate({ opacity: 1 }, 'slow');
}, 500);
}
function showDBError() {
setTimeout(function () {
$(".page-cover.page-error").show();
$("body").css({ "overflow": 'hidden' }, { "posiiton": "relative" });
}, 250);
}
function loadPageContentJS() {
setTimeout(function () {
$('.carousel').carousel()
$('.image-link').magnificPopup({ type: 'image' });
attachLinks();
loadMasks();
}, 250);
}
function loadReferral() {
var referralId = getUrlParameter('rid');
if (typeof referralId !== "undefined" && referralId != "") sessionStorage.setItem("referralId", referralId);
}
function loadRegistration() {
var presale = getUrlParameter('presale');
if (typeof presale !== "undefined" && presale != "") sessionStorage.setItem("presale", presale);
}
$scope.userData.displayUserInfo();
$scope.userData.displayCustomerInfo();
loadPageContent();
//loadLatestVideos();
loadReferral();
loadRegistration();
}
})(angular.module('app'));;
(function(app) {
'use strict';
app.directive('pageError', pageError);
function pageError() {
return {
restrict: 'E',
replace: false,
templateUrl: '/scripts/app/layout/pageError.html',
scope: {}
}
}
})(angular.module('common.ui'));;
(function (app) {
'use strict';
app.controller('topBarCtrl', topBarCtrl);
topBarCtrl.$inject = ['$rootScope', '$scope', 'apiService', 'notificationService', 'membershipService'];
function topBarCtrl($rootScope, $scope, apiService, notificationService, membershipService) {
var vm = this;
vm.role = '';
if (membershipService.isUserLoggedIn()) {
vm.role = $rootScope.repository.loggedUser.role;
}
vm.pageLocation = "";
vm.adminPageLocation = "";
vm.cartTotal = cartLS.total().toFixed(4);
vm.userData = $scope.$parent.userData
vm.logout = $scope.$parent.logout;
vm.signout = $scope.$parent.signout;
vm.loggedUser = $scope.$parent.loggedUser;
vm.username = $scope.$parent.loggedUser.username;
vm.cacheKey = "";
$scope.$on('updateCartTotal', function (event, data) {
//alert(data);
vm.cartTotal = data.toFixed(4);
var usdTotal = 0;
var items = cartLS.list();
for (var key in items) {
var item = items[key];
if (item.usdPrice > 0) {
usdTotal += item.usdPrice;
}
}
//return cartLS.total().toFixed(4) + " BTC / $" + usdTotal;
});
$scope.$on('updatePageLocation', function (event, data) {
vm.pageLocation = data;
});
$scope.$on('updateAdminPageLocation', function (event, data) {
vm.adminPageLocation = data;
});
$scope.$on('showUserData', function (event, data) {
vm.loggedUser = $scope.$parent.loggedUser;
});
}
})(angular.module('app'));;
(function(app) {
'use strict';
app.directive('topBar', topBar);
function topBar() {
return {
restrict: 'E',
replace: false,
templateUrl: '/scripts/app/layout/topBar.html',
scope: {},
controller: "topBarCtrl",
controllerAs: "vm"
}
}
})(angular.module('common.ui'));;
(function(app) {
'use strict';
app.directive('bottomBar', bottomBar);
function bottomBar() {
return {
restrict: 'E',
replace: false,
templateUrl: '/scripts/app/layout/bottomBar.html',
scope: {},
controller: "bottomBarCtrl",
controllerAs: "vm"
}
}
})(angular.module('common.ui'));;
(function (app) {
'use strict';
app.controller('bottomBarCtrl', bottomBarCtrl);
bottomBarCtrl.$inject = ['$scope', 'youtubeService'];
function bottomBarCtrl($scope, youtubeService) {
var vm = this;
vm.episodes = $scope.$parent.episodes;
vm.pageLocation = "";
vm.currentYear = new Date();
$scope.$on('updatePageLocation', function (event, data) {
vm.pageLocation = data;
});
$scope.$on('latestVideosLoaded', function (event, data) {
vm.episodes = $scope.$parent.episodes;
});
}
})(angular.module('app'));;
(function(app) {
'use strict';
app.directive('captcha', captcha);
function captcha() {
return {
restrict: 'E',
scope: { valid: '=' },
template: '{{a.value}} {{operation}} {{b.value}} = {{result}}',
controller: function ($scope) {
var show = Math.random() > 0.5;
var value = function (max) {
return Math.floor(max * Math.random());
};
var int = function (str) {
return parseInt(str, 10);
};
$scope.a = {
value: show ? undefined : 1 + value(4),
input: show
};
$scope.b = {
value: !show ? undefined : 1 + value(4),
input: !show
};
$scope.operation = '+';
$scope.result = 5 + value(5);
var a = $scope.a;
var b = $scope.b;
var result = $scope.result;
var checkValidity = function () {
if (a.value && b.value) {
var calc = int(a.value) + int(b.value);
$scope.valid = calc == result;
} else {
$scope.valid = false;
}
//$scope.$apply(); // needed to solve 2 cycle delay problem;
};
$scope.$watch('a.value', function () {
checkValidity();
});
$scope.$watch('b.value', function () {
checkValidity();
});
}
};
}
})(angular.module('common.ui'));;
(function(app) {
'use strict';
app.directive('customPager', customPager);
function customPager() {
return {
scope: {
page: '@',
pagesCount: '@',
totalCount: '@',
searchFunc: '&',
customPath: '@'
},
replace: true,
restrict: 'E',
templateUrl: '/scripts/app/directives/customPager.html',
controller: ['$scope', function ($scope) {
$scope.search = function (i) {
if ($scope.searchFunc) {
$scope.searchFunc({ page: i });
}
};
$scope.range = function () {
if (!$scope.pagesCount) { return []; }
var step = 2;
var doubleStep = step * 2;
var start = Math.max(0, $scope.page - step);
var end = start + 1 + doubleStep;
if (end > $scope.pagesCount) { end = $scope.pagesCount; }
var ret = [];
for (var i = start; i != end; ++i) {
ret.push(i);
}
return ret;
};
$scope.pagePlus = function(count)
{
return +$scope.page + count;
}
}]
}
}
})(angular.module('common.ui'));;
(function(app) {
'use strict';
app.directive('numbersOnly', numbersOnly);
function numbersOnly() {
return {
require: 'ngModel',
link: function (scope, element, attr, ngModelCtrl) {
function fromUser(text) {
if (text) {
var transformedInput = text.replace(/[^0-9-]/g, '');
if (transformedInput !== text) {
ngModelCtrl.$setViewValue(transformedInput);
ngModelCtrl.$render();
}
return transformedInput;
}
return undefined;
}
ngModelCtrl.$parsers.push(fromUser);
}
}
}
})(angular.module('common.ui'));;
(function(app) {
'use strict';
app.directive('mediaManager', mediaManager);
function mediaManager() {
return {
scope: {
useLocalPaths: '@'
},
templateUrl: '/scripts/app/directives/mediaManager.html',
controller: ['$scope', 'apiService', 'notificationService', 'fileUploadService', function ($scope, apiService, notificationService, fileUploadService) {
$scope.isLoading = true;
$scope.isDeleting = false;
$scope.mediaImage = null;
$scope.selectedImage = null;
$scope.imageURL = '';
$scope.Images = [];
$scope.prepareFiles = function ($files) {
$scope.mediaImage = $files;
};
$scope.select = function (image) {
if ($scope.selectedImage !== null) {
if ($scope.selectedImage.ID === image.ID) {
$scope.selectedImage = null;
}
else {
$scope.selectedImage = image;
}
}
else {
$scope.selectedImage = image;
}
};
$scope.insertImage = function (sForm) {
//$('#summernote').summernote('insertText', ''); //used so that the image is not inserted outside the editable area: commented out because this code also causes summernote to scroll to top after image is inserted
$('#summernote').summernote('restoreRange'); //restore cursor location
if ($scope.mediaImage !== null) {
$scope.isLoading = true;
fileUploadService.uploadMediaContentImageImage($scope.mediaImage, insertImageSuccess);
}
else if ($scope.imageURL.length > 0) {
$scope.isLoading = true;
var mediaContent = {
MediaTypeID: 1,
FileName: $scope.imageURL,
CreatedDate: new Date()
};
addImageFromUrl(mediaContent);
}
else if ($scope.selectedImage !== null) {
var path = getPath();
var url = path + $scope.selectedImage.FileName;
$('#summernote').summernote('insertImage', url, function ($image) {
$image.css('width', '50%');
});
hideModalAndClearForm();
}
else {
return;
}
};
$scope.removeImage = function () {
$scope.isDeleting = true;
var url = '/api/mediacontent/delete';
apiService.post(url, $scope.selectedImage,
removeImageSucceeded,
responseFailed
);
};
function removeImageSucceeded(response) {
$scope.Images = $scope.Images.filter(function (obj) {
return obj.ID !== $scope.selectedImage.ID;
});
$scope.selectedImage = null;
$scope.mediaImage = null;
$scope.isDeleting = false;
notificationService.displaySuccess('Successfully deleted image');
}
function addImageFromUrl(mediaContent) {
apiService.post('/api/mediacontent/add/url', mediaContent,
addImageFromUrlSucceeded,
responseFailed);
}
function addImageFromUrlSucceeded(result) {
$scope.isLoading = false;
$scope.Images.push(result.data);
var path = getPath();
var url = path + result.data.FileName;
$('#summernote').summernote('insertImage', url, function ($image) {
$image.css('width', '50%');
});
hideModalAndClearForm();
}
function loadImages() {
var url = '/api/mediacontent';
apiService.get(url, null,
loadImagesCompleted,
responseFailed
);
}
function loadImagesCompleted(result) {
$scope.Images = result.data;
$scope.isLoading = false;
}
function insertImageSuccess(result) {
$scope.isLoading = false;
$scope.Images.push(result);
var path = getPath();
var url = path + result.FileName;
$('#summernote').summernote('insertImage', url, function ($image) {
$image.css('width', '50%');
});
hideModalAndClearForm();
}
function responseFailed(response) {
$scope.isLoading = false;
notificationService.displayError(response.data.Message);
}
function hideModalAndClearForm() {
$scope.mediaImage = null;
$scope.selectedImage = null;
$scope.imageURL = '';
$('#library').scrollTop(0);
$('#mediaManagerModal').modal('hide');
}
function getPath() {
var path = 'https://unconfiscatable.com/content/images/mediamanager/';
if ($scope.useLocalPaths == 'true') {
path = '../../Content/images/mediamanager/';
}
return path;
}
$('#mediaManagerModal').on('hidden.bs.modal', function (e) {
//Cannot interact with angular so cannot clear form
})
loadImages();
}]
}
}
})(angular.module('common.ui'));;
(function(app) {
'use strict';
app.directive('componentRating', componentRating);
function componentRating() {
return {
restrict: 'A',
link: function ($scope, $element, $attrs) {
$element.raty({
score: $attrs.componentRating,
halfShow: false,
readOnly: $scope.isReadOnly,
noRatedMsg: "Not rated yet!",
starHalf: "../Content/images/raty/star-half.png",
starOff: "../Content/images/raty/star-off.png",
starOn: "../Content/images/raty/star-on.png",
hints: ["Poor", "Average", "Good", "Very Good", "Excellent"],
click: function (score, event) {
//Set the model value
$scope.movie.Rating = score;
//$scope.$apply();
}
});
}
}
}
})(angular.module('common.ui'));;
(function (app) {
'use strict';
app.controller('loginCtrl', loginCtrl);
loginCtrl.$inject = ['$scope', 'membershipService', 'notificationService', '$rootScope', '$location', '$http', '$cookieStore'];
function loginCtrl($scope, membershipService, notificationService, $rootScope, $location, $http, $cookieStore) {
$scope.pageClass = 'page-login';
var vm = this;
vm.login = login;
vm.user = {};
function login() {
if (vm.user.username.toLowerCase() != 'customer') {
membershipService.login(vm.user, loginCompleted)
}
}
function loginCompleted(result) {
if (result.data.success) {
vm.user.id = result.data.id;
vm.user.role = result.data.role;
membershipService.saveCredentials(vm.user);
notificationService.displaySuccess('Hello ' + vm.user.username);
$scope.userData.displayUserInfo();
if ($rootScope.previousState)
$location.path($rootScope.previousState);
else {
//for some reason on production server $locatoin.path doesn't work because
//the.net membership service for some reason does not recognize that the user has been logged in without a page refresh
//$location.path('/admin');
window.location.href = '/admin';
}
}
else {
notificationService.displayError('Login failed. Try again.');
}
}
}
})(angular.module('common.core'));;
(function (app) {
'use strict';
app.controller('logoutCtrl', logoutCtrl);
logoutCtrl.$inject = ['$scope', 'membershipService'];
function logoutCtrl($scope, membershipService) {
$scope.pageClass = 'page-logout';
var vm = this;
function logout() {
membershipService.removeCredentials();
window.location.href = '/';
}
logout();
}
})(angular.module('common.core'));;
(function (app) {
'use strict';
app.controller('signinCtrl', signinCtrl);
signinCtrl.$inject = ['$scope', 'membershipService', 'notificationService', '$rootScope', '$location', '$http', '$cookieStore'];
function signinCtrl($scope, membershipService, notificationService, $rootScope, $location, $http, $cookieStore) {
$rootScope.$broadcast("updatePageLocation", "");
$scope.pageClass = 'page-login';
var vm = this;
vm.login = login;
vm.user = {};
function login() {
if (vm.user.username.toLowerCase() != 'customer') {
membershipService.login(vm.user, loginCompleted)
}
}
function loginCompleted(result) {
if (result.data.success) {
vm.user.id = result.data.id;
vm.user.role = result.data.role;
membershipService.saveCredentials(vm.user);
notificationService.displaySuccess('Hello ' + vm.user.username);
$scope.userData.displayUserInfo();
if ($rootScope.previousState)
$location.path($rootScope.previousState);
else {
//for some reason on production server $locatoin.path doesn't work because
//the.net membership service for some reason does not recognize that the user has been logged in without a page refresh
//$location.path('/admin');
window.location.href = '/dashboard';
}
}
else {
notificationService.displayError('Login failed. Try again.');
}
}
scrollToTop();
}
})(angular.module('common.core'));;
(function (app) {
'use strict';
app.controller('signoutCtrl', signoutCtrl);
signoutCtrl.$inject = ['$scope', 'membershipService'];
function signoutCtrl($scope, membershipService) {
$scope.pageClass = 'page-logout';
var vm = this;
function logout() {
sessionStorage.removeItem("/api/customers/authenticate");
membershipService.removeCredentials();
window.location.href = '/signin';
}
logout();
}
})(angular.module('common.core'));;
(function (app) {
'use strict';
app.controller('resetPasswordCtrl', resetPasswordCtrl);
resetPasswordCtrl.$inject = ['$scope', '$rootScope', '$location', '$http', '$routeParams', 'apiService', 'notificationService'];
function resetPasswordCtrl($scope, $rootScope, $location, $http, $routeParams, apiService, notificationService) {
$scope.pageClass = 'page-resetpassword';
var vm = this;
vm.isLoading = true;
vm.isValidated = false;
vm.isComplete = false;
vm.errorMessage = "";
vm.isError = false;
vm.newPassword = "";
vm.resetPassword = function () {
if (vm.isValidated && vm.newPassword.length > 0) {
resetPassword();
}
}
function resetPassword() {
vm.isLoading = true;
if (vm.newPassword != vm.verifyPassword) {
$scope.sForm.verifypassword.$setValidity("mismatch", false);
return;
}
else {
$scope.sForm.verifypassword.$setValidity("mismatch", true);
}
var request = {
ID: $routeParams.cid,
RID: $routeParams.rid,
NewPassword: vm.newPassword
}
var url = '/api/customers/resetpassword/reset';
apiService.put(url, request,
resetPasswordCompleted,
resetPasswordFailed);
}
function resetPasswordCompleted(result) {
vm.isLoading = false;
vm.isComplete = true;
}
function resetPasswordFailed(response) {
vm.isLoading = false;
vm.isError = true;
vm.errorMessage = response.data.Message;
}
function getCustomer() {
var url = '/api/customers/resetpassword/verify/' + $routeParams.cid + '/' + $routeParams.rid;
apiService.get(url, null,
getCustomerCompleted,
getCustomerFailed
);
}
function getCustomerCompleted(result) {
vm.errorMessage = "";
vm.isError = false;
vm.isLoading = false;
vm.isValidated = true;
console.info(result);
}
function getCustomerFailed(response) {
vm.isLoading = false;
vm.isError = true;
vm.errorMessage = response.data.Message;
}
getCustomer();
}
})(angular.module('common.core'));;
(function (app) {
'use strict';
app.controller('forgotPasswordCtrl', forgotPasswordCtrl);
forgotPasswordCtrl.$inject = ['$scope', 'apiService', 'membershipService', 'notificationService', '$rootScope', '$location', '$http'];
function forgotPasswordCtrl($scope, apiService, membershipService, notificationService, $rootScope, $location, $http) {
$rootScope.$broadcast("updatePageLocation", "");
$scope.pageClass = 'page-forgotpassword';
var vm = this;
vm.isSuccess = false;
vm.resetPasswordRequest = resetPasswordRequest;
vm.user = {};
function resetPasswordRequest() {
if (vm.user.username.toLowerCase() != 'customer') {
var url = '/api/customers/resetpassword/request/' + vm.user.username;
apiService.post(url, null,
resetPasswordRequestCompleted,
loadFailed
);
}
}
function resetPasswordRequestCompleted(result) {
vm.user.username = "";
vm.isSuccess = true;
notificationService.displaySuccess("We've sent you an email to reset your password.");
}
function loadFailed(response) {
notificationService.displayError("Could not find that user.");
vm.isLoading = false;
}
}
})(angular.module('common.core'));;
(function (app) {
'use strict';
app.controller('invoiceCtrl', invoiceCtrl);
invoiceCtrl.$inject = ['$scope', '$sce', '$rootScope', '$location', '$http', '$routeParams', '$filter', 'notificationService', 'apiService', 'membershipService', 'bitcoinService'];
function invoiceCtrl($scope, $sce, $rootScope, $location, $http, $routeParams, $filter, notificationService, apiService, membershipService, bitcoinService) {
$rootScope.$broadcast("updatePageLocation", "payment");
$scope.pageClass = 'page-payment';
var vm = this;
vm.trust = $sce.trustAsHtml;
vm.trustSrc = function (src) {
return $sce.trustAsResourceUrl(src);
}
vm.isLoading = true;
vm.isCompleted = false;
vm.isValidated = false;
vm.errorMessage = "";
vm.isError = false;
vm.qrCode = "";
vm.orderData = {};
vm.formData = {};
vm.currentStep = 1;
vm.cacheKey = '';
vm.showHelp = function () {
$(".divHelp").slideToggle("slow");
}
vm.refresh = function (invoiceId) {
checkTransaction(invoiceId);
//vm.isCompleted = true;
}
vm.updateOrderBTCPayInvoice = function (btcPayInvoiceId) {
//update order with btcInvoiceId to link them together
updateBTCPayOrder(btcPayInvoiceId);
}
function getOrderData() {
var url = '/api/orders/invoice/' + $routeParams.customerId + '/' + $routeParams.invoiceId;
apiService.get(url, null,
loadDataCompleted,
loadFailed
);
}
function loadDataCompleted(result) {
vm.orderData = result.data;
vm.isCompleted = false;
vm.isLoading = false;
if (vm.orderData.Order.StatusID == 2) {
//getOrderDataFailed('This order has already been paid.');
vm.isCompleted = true;
}
else if (vm.orderData.Order.StatusID == 3) {
//getOrderDataFailed('This order has already been completed.');
vm.isCompleted = true;
}
else {
vm.isValidated = true;
//loadQrCodeURL();
//send to btcpay server
//submitForm(document.getElementById('btcForm'));
}
}
function loadFailed(response) {
vm.isLoading = false;
//vm.isError = true;
//vm.errorMessage = response.data.Message;
}
function getOrderDataFailed(message) {
vm.isLoading = false;
vm.isError = true;
vm.errorMessage = message;
}
function loadQrCodeURL() {
vm.qrCode = "https://chart.googleapis.com/chart?chs=225x225&chld=L|2&cht=qr&chl=bitcoin:" + vm.orderData.Order.Address + "?amount=" + vm.orderData.Order.TotalPaid + "%26label=ToneVays.com%26message=" + vm.orderData.Order.Description;
}
function checkTransaction(invoiceId) {
if (invoiceId == "") return;
vm.isLoading = true;
vm.isError = false;
var url = '/api/orders/invoice/' + invoiceId
apiService.get(url, null,
checkTransactionCompleted,
checkTransactionFailed
);
}
function checkTransactionCompleted(result) {
var tx = result.data;
if (tx.transactionId != "") {
vm.isCompleted = true;
}
else {
vm.isCompleted = false;
}
vm.isLoading = false;
vm.isValidated = true;
}
function checkTransactionFailed(response) {
//vm.isError = true;
//vm.errorMessage = "That TransactionId has already been registered.";
vm.isLoading = false;
vm.isCompleted = false;
}
function updateBTCPayOrder(BTCPayInvoiceID) {
var order = {
InvoiceId: vm.orderData.Order.InvoiceID,
BTCPayInvoiceID: BTCPayInvoiceID
}
var url = '/api/orders/updateInvoice/';
apiService.put(url, order,
updateBTCPayOrderCompleted,
updateBTCPayOrderFailed);
}
function updateBTCPayOrderCompleted(result) {
}
function updateBTCPayOrderFailed(response) {
}
getOrderData();
//$('.carousel').carousel('pause');
$scope.$on('$locationChangeStart', function (event) {
console.info('logged out');
membershipService.removeCredentials();
sessionStorage.removeItem(vm.cacheKey);
});
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('downloadCtrl', downloadCtrl);
downloadCtrl.$inject = ['$scope', 'notificationService', 'apiService', 'membershipService', 'bitcoinService', '$rootScope', '$location', '$http', '$routeParams', '$filter'];
function downloadCtrl($scope, notificationService, apiService, membershipService, bitcoinService, $rootScope, $location, $http, $routeParams, $filter) {
$rootScope.$broadcast("updatePageLocation", "download");
$scope.pageClass = 'page-download';
var vm = this;
vm.isLoading = true;
vm.isDownloadLoading = false;
vm.isValidated = false;
vm.errorMessage = "";
vm.isError = false;
vm.cacheKey = '';
vm.downloadButtonText = "Download Now";
vm.orderData = {};
vm.download = function () {
vm.isDownloadLoading = true;
vm.downloadButtonText = "Loading...";
downloadFile();
}
function getOrderData() {
vm.cacheKey = $routeParams.customerId + '|' + $routeParams.invoiceId;
if (sessionStorage.getItem(vm.cacheKey) == null) {
getOrderDataFailed('Error processing request.');
}
else {
getOrderDataCompleted(JSON.parse(sessionStorage.getItem(vm.cacheKey)));
}
}
function getOrderDataCompleted(result) {
vm.orderData = result;
vm.isLoading = false;
vm.isValidated = true;
}
function getOrderDataFailed(message) {
vm.isLoading = false;
vm.isError = true;
vm.errorMessage = message;
}
function downloadFile() {
var url = '/api/orders/file/' + vm.orderData.customerId + '/' + vm.orderData.invoiceId;
//window.open(url, '_blank', ''); //alternative method
$http({
method: 'GET',
url: url,
responseType: 'arraybuffer'
}).success(function (data, status, headers) {
headers = headers();
var filename = headers['x-filename'];
var contentType = headers['content-type'];
var linkElement = document.createElement('a');
try {
var blob = new Blob([data], { type: contentType });
var url = window.URL.createObjectURL(blob);
linkElement.setAttribute('href', url);
linkElement.setAttribute("download", filename);
var clickEvent = new MouseEvent("click", {
"view": window,
"bubbles": true,
"cancelable": false
});
linkElement.dispatchEvent(clickEvent);
downloadFileCompleted();
} catch (ex) {
downloadFileFailed(ex);
}
}).error(function (data) {
downloadFileFailed(data);
});
}
function downloadFileCompleted() {
vm.downloadButtonText = "Download Now";
vm.isDownloadLoading = false;
sessionStorage.removeItem(vm.cacheKey);
}
function downloadFileFailed(data) {
vm.downloadButtonText = "Download Now";
vm.isDownloadLoading = false;
vm.isError = true;
vm.errorMessage = data.Message;
}
getOrderData();
$scope.$on('$locationChangeStart', function (event) {
membershipService.removeCredentials();
});
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('authCtrl', authCtrl);
authCtrl.$inject = ['$scope', '$rootScope', '$routeParams', 'apiService', 'membershipService'];
function authCtrl($scope, $rootScope, $routeParams, apiService, membershipService) {
$scope.pageClass = 'page-admin-home';
var vm = this;
//hardcoded customer auth
vm.user = {
username: 'customer',
password: 'U)7wPJ`3D7a34k=N'
};
vm.isLoading = true;
vm.isValidated = false;
vm.errorMessage = "";
vm.isError = false;
vm.redirectURL = "";
vm.currencyTypeID = "";
function loadData() {
var url = '/api/orders/auth/' + $routeParams.customerId + '/' + $routeParams.invoiceId;
apiService.get(url, null,
loadDataCompleted,
loadFailed
);
}
function loadDataCompleted(result) {
vm.redirectURL = result.data.redirectURL;
vm.currencyTypeID = result.data.currencyTypeId;
vm.isValidated = true;
login();
}
function loadFailed(response) {
vm.isLoading = false;
vm.isError = true;
vm.errorMessage = response.data.Message;
$("#error").show();
}
function login() {
membershipService.login(vm.user, loginCompleted)
}
function loginCompleted(result) {
if (result.data.success) {
vm.user.id = result.data.id;
vm.user.role = result.data.role;
membershipService.saveCredentials(vm.user);
//redirect
if (vm.currencyTypeID == 1) {
window.location.href = '/' + $routeParams.method + '/' + $routeParams.customerId + '/' + $routeParams.invoiceId;
}
else if (vm.currencyTypeID == 2) {
window.location.href = vm.redirectURL;
}
}
else {
vm.errorMessage = "Error authenticating user.";
vm.isError = false;
}
}
loadData();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('indexCtrl', indexCtrl);
indexCtrl.$inject = ['$scope', '$rootScope', '$location', '$filter', '$sce', 'ngMeta', 'apiService', 'notificationService'];
function indexCtrl($scope, $rootScope, $location, $filter, $sce, ngMeta, apiService, notificationService) {
$rootScope.$broadcast("updatePageLocation", "conference");
$rootScope.$broadcast("updateCartTotal", cartLS.total());
$scope.pageClass = 'page-conference';
var vm = this;
vm.title = 'unconfiscatable-2024';
vm.trust = $sce.trustAsHtml;
vm.conferenceHeaderPageContent = $scope.$parent.getPageContent("UnconfiscatableHeader");
vm.conferenceMainPageContent = $scope.$parent.getPageContent("UnconfiscatableMain");
vm.conferenceFooterPageContent = $scope.$parent.getPageContent("UnconfiscatableFooter");
vm.trustSrc = function (src) {
return $sce.trustAsResourceUrl(src);
}
vm.submitButtonText = "Submit";
vm.conference = {};
vm.conferenceProducts = [];
vm.conferenceProductsForPurchase = [];
vm.pokerProducts = [];
vm.carnivoreProducts = [];
vm.pinballProducts = [];
vm.voteCategories = [];
vm.voteItems = [];
vm.seatsLeft1 = 0;
vm.seatsLeft2 = 0;
vm.seatsLeft3 = 0;
vm.enabledDiscounts = 0;
vm.loadingProduct = true;
vm.count = 0;
vm.isFullScheduleExpanded = false;
vm.expandFullScheduleText = "Expand to Show All";
vm.loadingRegister = false;
vm.isRegistered = false;
vm.registerButtonText = "Register";
vm.showRegistration = true;
vm.isError = false;
vm.errorMessage = "";
vm.cacheKey = "";
vm.cacheKey2 = "";
vm.cacheKey3 = "";
vm.cacheKey4 = "";
vm.message = {
CreatedDate: new Date(),
Contacted: false
};
vm.customer = {
CurrencyTypeID: "",
ConferenceProductId: null
};
vm.expandFullSchedule = function () {
if (vm.isFullScheduleExpanded) {
vm.isFullScheduleExpanded = false;
vm.expandFullScheduleText = "Expand to Show All";
$(".fa-arrow-up").hide();
$(".fa-arrow-down").show();
}
else {
vm.isFullScheduleExpanded = true;
vm.expandFullScheduleText = "Hide Full Speaker List";
$(".fa-arrow-up").show();
$(".fa-arrow-down").hide();
}
};
vm.showCouponCode = function () {
$("#couponCode").slideToggle("slow");
};
vm.register = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
vm.loadingRegister = true;
vm.registerButtonText = "Please Wait...";
apiService.post('/api/orders/new', vm.customer,
registerSucceded,
registerFailed);
};
//vm.selectConferenceProduct = function (conferenceProduct) {
// vm.customer.ConferenceProductId = conferenceProduct.ID;
// $('html, body').animate({ scrollTop: $('#registration').offset().top - 20 }, 300);
// $("#fname").focus();
//};
vm.selectConferenceProduct = function (conferenceProduct) {
var bInCart = "";
if (cartLS.get(conferenceProduct.ID) == undefined) {
var items = cartLS.list();
//console.log(conferenceProduct.Title);
if (conferenceProduct.Title.includes("VIP")) {
//need to not allow VIP + Event or VIP + Carnivory
for (var key in items) {
var item = items[key];
if (item.name.includes("Ticket")) {
bInCart = "Event Ticket Already Selected";
break;
}
}
}
if (conferenceProduct.Title.includes("Ticket")) {
//need to not allow Event + VIP
for (var key in items) {
var item = items[key];
if (item.name.includes("VIP")) {
bInCart = "VIP Already Selected";
break;
}
}
}
//if (conferenceProduct.Title.includes("Carnivory")) {
// //need to not allow Event + VIP
// for (var key in items) {
// var item = items[key];
// if (item.name.includes("VIP")) {
// bInCart = "VIP Already Selected";
// break;
// }
// }
//}
}
else {
bInCart = "Item Already In Cart";
}
if (bInCart !== "") {
notificationService.displayInfo(bInCart);
}
else {
cartLS.add({ id: conferenceProduct.ID, name: conferenceProduct.Title, price: conferenceProduct.Price, usdPrice: conferenceProduct.PriceFiat });
// cartLS.add({ id: 2, name: "Product 2", price: 100 }, 2);
vm.cartTotal = cartLS.total();
$rootScope.$broadcast("updateCartTotal", cartLS.total());
notificationService.displaySuccess('Successfully Added to Cart');
}
//console.log(cartLS.get(conferenceProduct.ID));
};
vm.pokerRegister = function (path) {
$location.path(path);
};
vm.vote = function () {
var voteItem = vm.voteItems.filter(function (entry) {
return (entry.ID == vm.choice);
})[0];
//alert(voteItem.Title);
voteItem.VotesTotal = 1;
apiService.put('/api/votes/public/update', voteItem,
voteSucceded,
voteFailed);
}
function voteSucceded(result) {
notificationService.displaySuccess('Successfully voted');
vm.count += 1;
}
function voteFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function loadVoteData() {
var url = '/api/votes/public/categories';
apiService.get(url, null,
loadVoteCategoriesCompleted,
loadVoteCategoriesFailed
);
}
function loadVoteCategoriesCompleted(result) {
var data = result.data;
vm.voteCategories = data;
//if (vm.voteCategories.length > 0) {
// loadVoteItems(vm.voteCategories[0].ID);
//}
loadVoteItems();
vm.isLoading = false;
}
function loadVoteCategoriesFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function loadVoteItems() {
var url = '/api/votes/public';
apiService.get(url, null,
loadVoteItemsCompleted,
loadVoteItemsFailed
);
}
function loadVoteItemsCompleted(result) {
var voteItems= result.data;
vm.voteItems = voteItems;
vm.isLoading = false;
}
function loadVoteItemsFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
vm.submit = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
vm.loading = true;
vm.submitButtonText = "Please Wait...";
apiService.post('/api/emails/conference', vm.message,
submitSucceded,
submitFailed);
};
function submitSucceded(response) {
vm.loading = false;
vm.submitButtonText = "Submit";
vm.isCompleted = true;
vm.isError = false;
vm.errorMessage = "";
vm.customer = response.data;
$scope.sForm3.$setPristine();
}
function submitFailed(response) {
vm.loading = false;
vm.submitButtonText = "Submit";
vm.isError = true;
vm.errorMessage = response.data.Message;
}
function loadConferenceProducts() {
var url = '/api/conferenceproducts/title/' + decodeURIComponent(vm.title); //should be title here
vm.cacheKey2 = url;
console.log(url);
//sessionStorage.removeItem(vm.cacheKey2);
if (sessionStorage.getItem(vm.cacheKey2) == null) {
apiService.get(url, null,
loadConferenceProductsCompleted,
loadFailed
);
}
else {
loadConferenceProductsCompleted(JSON.parse(sessionStorage.getItem(vm.cacheKey2)));
}
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
function loadConferenceProductsCompleted(result) {
if (sessionStorage.getItem(vm.cacheKey2) == null) sessionStorage.setItem(vm.cacheKey2, JSON.stringify(result));
var allConferenceProducts = result.data;
if (allConferenceProducts.length > 0) {
//vm.conferenceProducts = allConferenceProducts.filter(function (entry) {
//return (entry.Conference.Title.indexOf('Unconfiscatable') > -1);
//});
vm.conferenceProducts = allConferenceProducts;
vm.conference = vm.conferenceProducts[0].Conference;
loadMetaData();
vm.conferenceProductsForPurchase = vm.conferenceProducts.filter(function (entry) {
return (entry.IsSoldOut == false);
});
if (vm.conferenceProductsForPurchase.length > 0) {
vm.customer.ConferenceProductId = vm.conferenceProducts[0].ID;
}
vm.pokerProducts = allConferenceProducts.filter(function (entry) {
return (entry.Conference.Title.indexOf('Poker') > -1 && entry.IsSoldOut == false);
});
if (vm.pokerProducts.length > 0) {
vm.seatsLeft1 = vm.pokerProducts[0].SeatsLeft;
}
vm.carnivoreProducts = allConferenceProducts.filter(function (entry) {
return (entry.Conference.Title.indexOf('Carnivory') > -1 && entry.IsSoldOut == false);
});
if (vm.carnivoreProducts.length > 0) {
vm.seatsLeft2 = vm.carnivoreProducts[0].SeatsLeft;
}
vm.pinballProducts = allConferenceProducts.filter(function (entry) {
return (entry.Conference.Title.indexOf('Pinball') > -1 && entry.IsSoldOut == false);
});
if (vm.pinballProducts.length > 0) {
vm.seatsLeft3 = vm.pinballProducts[0].SeatsLeft;
}
vm.loadingProduct = false;
//loadDiscounts();
$('#VenueAddress').html(vm.conference.VenueAddress);
$('#VenueTitle').html(vm.conference.VenueTitle);
}
}
function registerSucceded(response) {
vm.loadingRegister = false;
vm.registerButtonText = "";
vm.isRegistered = true;
vm.isError = false;
vm.errorMessage = "";
$scope.sForm.$setPristine();
$('html, body').animate({ scrollTop: $("#registration").offset().top - 30 }, 1000);
}
function loadDiscounts() {
var url = '/api/discounts/count/3';
vm.cacheKey4 = url;
//sessionStorage.removeItem(vm.cacheKey4);
if (sessionStorage.getItem(vm.cacheKey4) == null) {
apiService.get(url, null,
loadDiscountsCompleted,
loadFailed
);
}
else {
loadDiscountsCompleted(JSON.parse(sessionStorage.getItem(vm.cacheKey4)));
}
}
function loadDiscountsCompleted(result) {
if (sessionStorage.getItem(vm.cacheKey4) == null) sessionStorage.setItem(vm.cacheKey4, JSON.stringify(result));
vm.enabledDiscounts = result.data.count;
vm.loadingProduct = false;
}
function registerFailed(response) {
vm.loadingRegister = false;
vm.registerButtonText = "Register";
vm.isError = true;
vm.errorMessage = response.data.Message;
}
function loadMetaData() {
ngMeta.setTitle(vm.conference.Title);
ngMeta.setTag('description', vm.conference.Title);
}
function loadReferral() {
if (sessionStorage.getItem("referralId") != null) {
vm.customer.ReferralID = sessionStorage.getItem("referralId");
}
}
function loadRegistration() {
//if (sessionStorage.getItem("presale") != null) {
//show registration form if presale mateches year
//var currYear = (new Date().getFullYear() + 1).toString(); // returns the current year
//var year = sessionStorage.getItem("presale").toString();
//if (currYear === year) {
vm.showRegistration = true;
//alert(vm.showRegistration);
//}
//}
}
$scope.$on('pageContentLoaded', function (event, data) {
vm.conferenceHeaderPageContent = $scope.$parent.getPageContent("UnconfiscatableHeader");
vm.conferenceMainPageContent = $scope.$parent.getPageContent("UnconfiscatableMain");
vm.conferenceFooterPageContent = $scope.$parent.getPageContent("UnconfiscatableFooter");
});
loadRegistration();
loadConferenceProducts(); //TODO: make this take mutiple products seperated by commas
loadMasks();
loadVoteData();
loadReferral();
setTimeout(function () {
$('.image-link').magnificPopup({ type: 'image' });
}, 250);
//show side panel on google embed map
setTimeout(function () { $('div.i4ewOd-pzNkMb-ornU0b-b0t70b-Bz112c').click(); }, 3000);
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('cartCtrl', cartCtrl);
cartCtrl.$inject = ['$scope', '$rootScope', '$filter', '$sce', 'apiService', 'notificationService'];
function cartCtrl($scope, $rootScope, $filter, $sce, apiService, notificationService) {
$rootScope.$broadcast("updatePageLocation", "cart");
$scope.pageClass = 'page-conference';
var vm = this;
vm.title = 'unconfiscatable';
vm.trust = $sce.trustAsHtml;
vm.CartItems = [];
vm.ExtraRegistrantQuantity = [];
vm.trustSrc = function (src) {
return $sce.trustAsResourceUrl(src);
}
vm.submitButtonText = "Submit";
vm.customers = [];
vm.conference = {};
vm.conferenceProducts = [];
vm.conferenceProductsForPurchase = [];
vm.products = [];
vm.seatsLeft1 = 0;
vm.seatsLeft2 = 0;
vm.enabledDiscounts = 0;
vm.loadingProduct = true;
vm.checkCart = false;
vm.isFullScheduleExpanded = false;
vm.expandFullScheduleText = "Expand to Show All";
vm.loadingRegister = false;
vm.isRegistered = false;
vm.registerButtonText = "Register";
vm.isError = false;
vm.errorMessage = "";
vm.cacheKey = "";
vm.cacheKey2 = "";
vm.cacheKey3 = "";
vm.cacheKey4 = "";
vm.message = {
CreatedDate: new Date(),
Contacted: false
};
vm.customer = {
CurrencyTypeID: "",
ConferenceProductId: null
};
vm.showCouponCode = function () {
$("#couponCode").slideToggle("slow");
};
vm.showRegister = function () {
vm.checkCart = true;
vm.customers = [];
for (var key in vm.ExtraRegistrantQuantity) {
var value = vm.ExtraRegistrantQuantity[key];
var customer = {
FirstName: '',
LastName: '',
Email: '',
Id: value
};
vm.customers.push(customer);
}
//console.log('customers: ' + vm.customers.length);
};
vm.showCart = function () {
vm.checkCart = false;
};
vm.register = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
vm.loadingRegister = true;
vm.registerButtonText = "Please Wait...";
vm.customer.ConferenceProductIds = new Array();
//FIX this, should be separate array sent to API vs fields
//
//
//vm.customer.AdditionalCustomers = vm.customers;
//
//
//loop through selected id's
for (var key in vm.CartItems) {
var value = vm.CartItems[key];
if (vm.customer.ConferenceProductId == undefined) {
vm.customer.ConferenceProductId = value.id;
console.log('item ' + value.id);
}
else {
//if quantity > 1 add multiple of same id
if (value.quantity > 1) {
for (var i = 0; i < value.quantity; i++) {
vm.customer.ConferenceProductIds.push(value.id);
}
}
else {
vm.customer.ConferenceProductIds.push(value.id);
}
}
}
//alert(vm.customer.ConferenceProductIds.length);
apiService.post('/api/orders/new', vm.customer,
registerSucceded,
registerFailed);
};
vm.getTotalPrice = function () {
var usdTotal = 0;
var items = cartLS.list();
for (var key in items) {
var item = items[key];
if (item.usdPrice > 0) {
usdTotal += item.usdPrice;
}
}
return cartLS.total().toFixed(4) + " BTC / $" + usdTotal;
}
vm.remove = function (Id) {
cartLS.remove(Id);
vm.CartItems = cartLS.list();
$rootScope.$broadcast("updateCartTotal", cartLS.total());
}
vm.setQuantity = function (amount, item) {
if (amount === -1) {
cartLS.quantity(item.id, -1);
vm.ExtraRegistrantQuantity.splice(vm.ExtraRegistrantQuantity.findIndex(({ Id }) => Id == item.id), 1);
console.log(vm.ExtraRegistrantQuantity)
}
else {
cartLS.quantity(item.id, 1);
var quantity = cartLS.get(item.id).quantity;
if (quantity > 1) {
var customerItem = {
Id: item.id,
quantity: cartLS.get(item.id).quantity
};
}
vm.ExtraRegistrantQuantity.push(customerItem);
}
vm.CartItems = cartLS.list();
$rootScope.$broadcast("updateCartTotal", cartLS.total());
}
//vm.selectConferenceProduct = function (conferenceProduct) {
// cartLS.add({ id: conferenceProduct.ID, name: conferenceProduct.Title, price: conferenceProduct.Price });
// // cartLS.add({ id: 2, name: "Product 2", price: 100 }, 2);
// console.log(cartLS.total());
// console.log(cartLS.get(conferenceProduct.ID))
//};
//vm.deselectConferenceProduct = function (conferenceProduct) {
// cartLS.remove(conferenceProduct.ID);
// // cartLS.add({ id: 2, name: "Product 2", price: 100 }, 2);
// console.log(cartLS.total());
// console.log(cartLS.get(conferenceProduct.ID))
//};
function loadConferenceProducts() {
var itemTotal = cartLS.total();
if (itemTotal > 0) {
vm.CartItems = cartLS.list();
//var maxRegistrants = 0;
//for (var key in vm.CartItems) {
// var value = vm.CartItems[key];
// console.log("item: " + value.id);
// //set quantity to max item quantity
// if (value.quantity > maxRegistrants) {
// maxRegistrants = value.quantity;
// }
//}
//if (maxRegistrants < vm.customers.length) {
// var customer = {
// FirstName: '',
// LastName: '',
// Email: ''
// };
// vm.customers.push(customer);
//}
}
//var url = '/api/conferenceproducts/title/' + decodeURIComponent(vm.title);
//vm.cacheKey2 = url;
////sessionStorage.removeItem(vm.cacheKey2);
//if (sessionStorage.getItem(vm.cacheKey2) == null) {
// apiService.get(url, null,
// loadConferenceProductsCompleted,
// loadFailed
// );
//}
//else {
// loadConferenceProductsCompleted(JSON.parse(sessionStorage.getItem(vm.cacheKey2)));
//}
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
function loadConferenceProductsCompleted(result) {
if (sessionStorage.getItem(vm.cacheKey2) == null) sessionStorage.setItem(vm.cacheKey2, JSON.stringify(result));
vm.conferenceProducts = result.data;
if (vm.conferenceProducts.length > 0) {
vm.conference = vm.conferenceProducts[0].Conference;
//get conference products that are not sold out
vm.conferenceProductsForPurchase = vm.conferenceProducts.filter(function (entry) {
return (entry.IsSoldOut == false);
});
//vm.conferenceProductsForPurchase = []; //hardcoded once conference is over
if (vm.conferenceProductsForPurchase.length > 0) {
vm.customer.ConferenceProductId = vm.conferenceProducts[0].ID;
}
loadDiscounts();
}
}
function registerSucceded(response) {
vm.loadingRegister = false;
vm.registerButtonText = "";
vm.isError = false;
vm.errorMessage = "";
//clear cart items from memory
cartLS.destroy();
if (response.data.redirectUrl != null) {
//redirect to payment
window.location.href = response.data.redirectUrl;
}
else {
vm.isRegistered = true;
$scope.sForm.$setPristine();
$('html, body').animate({ scrollTop: $("#registration").offset().top - 30 }, 1000);
}
}
function loadDiscounts() {
var url = '/api/discounts/count/3';
vm.cacheKey4 = url;
//sessionStorage.removeItem(vm.cacheKey4);
if (sessionStorage.getItem(vm.cacheKey4) == null) {
apiService.get(url, null,
loadDiscountsCompleted,
loadFailed
);
}
else {
loadDiscountsCompleted(JSON.parse(sessionStorage.getItem(vm.cacheKey4)));
}
}
function loadDiscountsCompleted(result) {
if (sessionStorage.getItem(vm.cacheKey4) == null) sessionStorage.setItem(vm.cacheKey4, JSON.stringify(result));
vm.enabledDiscounts = result.data.count;
vm.loadingProduct = false;
}
function registerFailed(response) {
vm.loadingRegister = false;
vm.registerButtonText = "Register";
vm.isError = true;
vm.errorMessage = response.data.Message;
}
loadConferenceProducts();
loadMasks();
//show side panel on google embed map
//setTimeout(function () { $('div.i4ewOd-pzNkMb-ornU0b-b0t70b-Bz112c').click(); }, 3000);
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('contactCtrl', contactCtrl);
contactCtrl.$inject = ['$scope', '$rootScope', '$filter', '$sce', 'apiService', 'notificationService'];
function contactCtrl($scope, $rootScope, $filter, $sce, apiService, notificationService) {
$rootScope.$broadcast("updatePageLocation", "contact");
$scope.pageClass = 'page-contact';
var vm = this;
vm.categories = [{ name: 'Category', id: 0 }, { name: 'Workshop', id: 1 }, { name: 'Indicator', id: 2 }, { name: 'Conference', id: 3 }, { name: 'Carnivore Dinner', id: 4 }, { name: 'Other', id: 5 }];
vm.departments = [{ name: 'Website Issue', id: 0 }, { name: 'Info/General', id: 1 }, { name: 'Technical Support', id: 2 }, { name: 'Billing', id: 3 }, { name: 'Other', id: 4 }];
vm.isCompleted = false;
vm.loading = false;
vm.submitButtonText = "Submit";
vm.isError = false;
vm.errorMessage = "";
vm.message = {
Category: "",
CategoryID: 0,
Department: "",
DepartmentID: 0,
CreatedDate: new Date(),
Contacted: false
};
vm.submit = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
{
var found = $filter('filter')(vm.categories, { id: vm.message.CategoryID }, true);
if (found.length) {
vm.message.Category = found[0].name;
}
}
{
var found = $filter('filter')(vm.departments, { id: vm.message.DepartmentID }, true);
if (found.length) {
vm.message.Department = found[0].name;
}
}
vm.loading = true;
vm.submitButtonText = "Please Wait...";
apiService.post('/api/emails/contact', vm.message,
submitSucceded,
submitFailed);
};
function submitSucceded(response) {
vm.loading = false;
vm.submitButtonText = "Submit";
vm.isCompleted = true;
vm.isError = false;
vm.errorMessage = "";
vm.customer = response.data;
$scope.sForm2.$setPristine();
}
function submitFailed(response) {
vm.loading = false;
vm.submitButtonText = "Submit";
vm.isError = true;
vm.errorMessage = response.data.Message;
}
scrollToTop();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('eventRequestCtrl', eventRequestCtrl);
eventRequestCtrl.$inject = ['$scope', '$rootScope', '$filter', '$sce', 'apiService', 'notificationService'];
function eventRequestCtrl($scope, $rootScope, $filter, $sce, apiService, notificationService) {
$rootScope.$broadcast("updatePageLocation", "contact");
$scope.pageClass = 'page-contact';
var vm = this;
vm.requestTypes = [
{ id: '', name: 'Select Request Type' },
{ id: 1, name: 'Conference (solo, panel or moderating)' },
{ id: 2, name: 'Interview/Live on-camera appearance (in-person)' },
{ id: 3, name: 'Interview (not in-person, including live streaming)' },
{ id: 4, name: 'Workshop/Presentation (independent of conference, to group)' },
{ id: 5, name: 'Personal Consulting (one-on-one)' },
{ id: 6, name: 'Group Consulting (up to 10 people)' },
{ id: 7, name: 'Corporate Consulting (for verified businesses)' },
{ id: 8, name: 'Webinar' },
{ id: 9, name: 'Meet Up' },
{ id: 10, name: 'Other' }
];
vm.trust = $sce.trustAsHtml;
vm.eventRequestPageContent = $scope.$parent.getPageContent("EventRequest");
vm.trustSrc = function (src) {
return $sce.trustAsResourceUrl(src);
}
vm.isCompleted = false;
vm.loading = false;
vm.submitButtonText = "Submit Request";
vm.isError = false;
vm.errorMessage = "";
vm.datepicker = {};
vm.datepicker2 = {};
vm.dateOptions = {
formatYear: 'yy',
startingDay: 1,
showWeeks: false
};
vm.openDatePicker = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker.opened = true;
};
vm.openDatePicker2 = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker2.opened = true;
};
vm.message = {
RequestTypeID: "",
CreatedDate: new Date()
};
vm.submit = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
if (vm.message.RequestTypeID == 1 || vm.message.RequestTypeID == 2 || vm.message.RequestTypeID == 3 || vm.message.RequestTypeID == 7) {
if (typeof vm.message.Website === 'undefined' || vm.message.Website === "") {
vm.isError = true;
vm.errorMessage = "Website Required.";
return;
}
else {
vm.errorMessage = "";
vm.isError = false;
}
}
var found = $filter('filter')(vm.requestTypes, { id: vm.message.RequestTypeID }, true);
if (found.length) {
vm.message.RequestType = found[0].name;
}
vm.loading = true;
vm.submitButtonText = "Please Wait...";
apiService.post('/api/emails/eventrequest', vm.message,
submitSucceded,
submitFailed);
};
function submitSucceded(response) {
vm.loading = false;
vm.submitButtonText = "Submit";
vm.isCompleted = true;
vm.isError = false;
vm.errorMessage = "";
vm.customer = response.data;
$scope.sForm2.$setPristine();
}
function submitFailed(response) {
vm.loading = false;
vm.submitButtonText = "Submit";
vm.isError = true;
vm.errorMessage = response.data.Message;
}
$scope.$on('pageContentLoaded', function (event, data) {
vm.eventRequestPageContent = $scope.$parent.getPageContent("EventRequest");
});
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('sponsorshipsCtrl', sponsorshipsCtrl);
sponsorshipsCtrl.$inject = ['$scope', '$rootScope', '$filter', '$sce', 'ngMeta', 'apiService', 'notificationService'];
function sponsorshipsCtrl($scope, $rootScope, $filter, $sce, ngMeta, apiService, notificationService) {
$rootScope.$broadcast("updatePageLocation", "sponsorships");
$scope.pageClass = 'page-conference';
var vm = this;
vm.title = 'unconfiscatable-sponsorships-2023';
vm.trust = $sce.trustAsHtml;
vm.pageContent = $scope.$parent.getPageContent("Sponsorships");
vm.trustSrc = function (src) {
return $sce.trustAsResourceUrl(src);
}
vm.submitButtonText = "Submit";
vm.showRegistration = true;
vm.conference = {};
vm.conferenceProducts = [];
vm.conferenceProductsForPurchase = [];
vm.seatsLeft = 0;
vm.isSoldOut = false;
vm.loadingProduct = true;
vm.loadingRegister = false;
vm.isRegistered = false;
vm.registerButtonText = "Register";
vm.isError = false;
vm.errorMessage = "";
vm.cacheKey = "";
vm.customer = {
CurrencyTypeID: 1,
ProductId: null
};
vm.showCouponCode = function () {
$("#couponCode").slideToggle("slow");
};
vm.selectSponsorshipProduct = function (sponsorshipProduct) {
var bInCart = "";
//alert(sponsorshipProduct.ID)
if (cartLS.get(sponsorshipProduct.ID) == undefined) {
var items = cartLS.list();
//console.log(items);
//if (sponsorshipProduct.Title.includes("VIP")) {
// //need to not allow VIP + Event or VIP + Carnivory
// for (var key in items) {
// var item = items[key];
// if (item.name.includes("Ticket") || item.name.includes("Carnivory")) {
// bInCart = "Event Ticket Already Selected";
// break;
// }
// }
//}
//if (conferenceProduct.Title.includes("Event")) {
// //need to not allow Event + VIP
// for (var key in items) {
// var item = items[key];
// if (item.name.includes("VIP")) {
// bInCart = "VIP Already Selected";
// break;
// }
// }
//}
//if (conferenceProduct.Title.includes("Carnivory")) {
// //need to not allow Event + VIP
// for (var key in items) {
// var item = items[key];
// if (item.name.includes("VIP")) {
// bInCart = "VIP Already Selected";
// break;
// }
// }
//}
}
else {
bInCart = "Item Already In Cart";
}
if (bInCart !== "") {
notificationService.displayInfo(bInCart);
}
else {
console.log(sponsorshipProduct);
cartLS.add({ id: sponsorshipProduct.ID, name: sponsorshipProduct.Title, price: sponsorshipProduct.Price, usdPrice: sponsorshipProduct.Price });
//cartLS.add({ id: 2, name: "Product 2", price: 100 }, 2);
vm.cartTotal = cartLS.total();
$rootScope.$broadcast("updateCartTotal", cartLS.total());
notificationService.displaySuccess('Successfully Added to Cart');
}
//console.log(cartLS.get(conferenceProduct.ID));
};
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
function loadSponsorshipProducts() {
var url = '/api/conferenceproducts/sponsorships/';
vm.cacheKey = url;
//sessionStorage.removeItem(vm.cacheKey);
if (sessionStorage.getItem(vm.cacheKey) == null) {
apiService.get(url, null,
loadSponsorshipProductsCompleted,
loadFailed
);
}
else {
loadSponsorshipProductsCompleted(JSON.parse(sessionStorage.getItem(vm.cacheKey)));
}
}
function loadRegistration() {
if (sessionStorage.getItem("presale") != null) {
//show registration form if presale mateches year
var currYear = (new Date().getFullYear() + 1).toString(); // returns the current year
var year = sessionStorage.getItem("presale").toString();
if (currYear === year) {
vm.showRegistration = true;
//alert(vm.showRegistration);
}
}
}
function loadSponsorshipProductsCompleted(result) {
if (sessionStorage.getItem(vm.cacheKey) == null) sessionStorage.setItem(vm.cacheKey, JSON.stringify(result));
vm.sponsorshipProducts = result.data;
if (vm.sponsorshipProducts.length > 0) {
//get products that are not sold out
vm.sponsorshipProductsForPurchase = vm.sponsorshipProducts.filter(function (entry) {
return (entry.IsSoldOut == false);
});
if (vm.sponsorshipProductsForPurchase.length > 0) {
vm.seatsLeft = vm.sponsorshipProducts[0].SeatsLeft;
vm.customer.SponsorshipProductId = vm.sponsorshipProducts[0].ID;
}
else {
vm.isSoldOut = true;
}
vm.loadingProduct = false;
//loadDiscounts();
}
}
//function loadMetaData() {
// ngMeta.setTitle(vm.conference.Title);
// ngMeta.setTag('description', vm.conference.Title);
//}
$scope.$on('pageContentLoaded', function (event, data) {
vm.pageContent = $scope.$parent.getPageContent("Sponsorships");
});
loadSponsorshipProducts();
//loadRegistration();
scrollToTop();
loadMasks();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('unconfiscatable2019Ctrl', unconfiscatable2019Ctrl);
unconfiscatable2019Ctrl.$inject = ['$scope', '$rootScope', '$filter', '$sce', 'ngMeta', 'apiService', 'notificationService'];
function unconfiscatable2019Ctrl($scope, $rootScope, $filter, $sce, ngMeta, apiService, notificationService) {
$rootScope.$broadcast("updatePageLocation", "conference");
$scope.pageClass = 'page-conference';
var vm = this;
vm.title = 'unconfiscatable';
vm.trust = $sce.trustAsHtml;
//vm.indicatorPageContent = $scope.$parent.getPageContent("Indicator");
//vm.indicatorFaqPageContent = $scope.$parent.getPageContent("IndicatorFaq");
//vm.indicatorTestimonialsPageContent = $scope.$parent.getPageContent("IndicatorTestimonials");
vm.trustSrc = function (src) {
return $sce.trustAsResourceUrl(src);
}
vm.submitButtonText = "Submit";
vm.conference = {};
vm.conferenceProducts = [];
vm.conferenceProductsForPurchase = [];
vm.products = [];
vm.seatsLeft1 = 0;
vm.seatsLeft2 = 0;
vm.enabledDiscounts = 0;
vm.loadingProduct = true;
vm.isFullScheduleExpanded = false;
vm.expandFullScheduleText = "Expand to Show All";
vm.loadingRegister = false;
vm.isRegistered = false;
vm.registerButtonText = "Register";
vm.isError = false;
vm.errorMessage = "";
vm.cacheKey = "";
vm.cacheKey2 = "";
vm.cacheKey3 = "";
vm.cacheKey4 = "";
vm.message = {
CreatedDate: new Date(),
Contacted: false
};
vm.customer = {
CurrencyTypeID: "",
ConferenceProductId: null
};
vm.expandFullSchedule = function () {
if (vm.isFullScheduleExpanded) {
vm.isFullScheduleExpanded = false;
vm.expandFullScheduleText = "Expand to Show All";
$(".fa-arrow-up").hide();
$(".fa-arrow-down").show();
}
else {
vm.isFullScheduleExpanded = true;
vm.expandFullScheduleText = "Hide Full Speaker List";
$(".fa-arrow-up").show();
$(".fa-arrow-down").hide();
}
};
vm.showCouponCode = function () {
$("#couponCode").slideToggle("slow");
};
vm.register = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
vm.loadingRegister = true;
vm.registerButtonText = "Please Wait...";
apiService.post('/api/orders/new', vm.customer,
registerSucceded,
registerFailed);
};
vm.selectConferenceProduct = function (conferenceProduct) {
vm.customer.ConferenceProductId = conferenceProduct.ID;
$('html, body').animate({ scrollTop: $('#registration').offset().top - 20 }, 300);
$("#fname").focus();
};
vm.submit = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
vm.loading = true;
vm.submitButtonText = "Please Wait...";
apiService.post('/api/emails/conference', vm.message,
submitSucceded,
submitFailed);
};
function submitSucceded(response) {
vm.loading = false;
vm.submitButtonText = "Submit";
vm.isCompleted = true;
vm.isError = false;
vm.errorMessage = "";
vm.customer = response.data;
$scope.sForm3.$setPristine();
}
function submitFailed(response) {
vm.loading = false;
vm.submitButtonText = "Submit";
vm.isError = true;
vm.errorMessage = response.data.Message;
}
function loadConferenceProducts() {
var url = '/api/conferenceproducts/title/' + decodeURIComponent(vm.title); //should be title here
vm.cacheKey2 = url;
//sessionStorage.removeItem(vm.cacheKey2);
if (sessionStorage.getItem(vm.cacheKey2) == null) {
apiService.get(url, null,
loadConferenceProductsCompleted,
loadFailed
);
}
else {
loadConferenceProductsCompleted(JSON.parse(sessionStorage.getItem(vm.cacheKey2)));
}
var url2 = '/api/conferenceproducts/title/carnivory-club'; //should be title here
vm.cacheKey3 = url2;
//sessionStorage.removeItem(vm.cacheKey3);
if (sessionStorage.getItem(vm.cacheKey3) == null) {
apiService.get(url2, null,
loadCarnivoreProductsCompleted,
loadFailed
);
}
else {
loadCarnivoreProductsCompleted(JSON.parse(sessionStorage.getItem(vm.cacheKey3)));
}
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
function loadConferenceProductsCompleted(result) {
if (sessionStorage.getItem(vm.cacheKey2) == null) sessionStorage.setItem(vm.cacheKey2, JSON.stringify(result));
vm.conferenceProducts = result.data;
if (vm.conferenceProducts.length > 0) {
vm.conference = vm.conferenceProducts[0].Conference;
loadMetaData();
//vm.conferenceProducts.reverse(); //temporary
//get conference products that are not sold out
vm.conferenceProductsForPurchase = vm.conferenceProducts.filter(function (entry) {
return (entry.IsSoldOut == false);
});
if (vm.conferenceProductsForPurchase.length > 0) {
vm.customer.ConferenceProductId = vm.conferenceProducts[0].ID;
}
loadDiscounts();
}
}
function loadCarnivoreProductsCompleted(result) {
if (sessionStorage.getItem(vm.cacheKey3) == null) sessionStorage.setItem(vm.cacheKey3, JSON.stringify(result));
var carnivoreProducts = result.data;
carnivoreProducts.reverse(); //temporary
if (carnivoreProducts.length > 0) {
vm.seatsLeft2 = carnivoreProducts[0].SeatsLeft;
}
}
function loadProducts() {
var url = '/api/products/public';
vm.cacheKey = url;
//sessionStorage.removeItem(vm.cacheKey);
if (sessionStorage.getItem(vm.cacheKey) == null) {
apiService.get(url, null,
loadProductsCompleted,
loadFailed
);
}
else {
loadProductsCompleted(JSON.parse(sessionStorage.getItem(vm.cacheKey)));
}
}
function loadProductsCompleted(result) {
if (sessionStorage.getItem(vm.cacheKey) == null) sessionStorage.setItem(vm.cacheKey, JSON.stringify(result));
vm.products = result.data;
var product1 = vm.products.filter(function (entry) {
return (entry.Title.indexOf('Poker Tournament') > -1);
})[0];
//vm.seatsLeft1 = product1.SeatsLeft;
vm.seatsLeft1 = 0;
//vm.seatsLeft2 = product2.SeatsLeft - 10;
}
function registerSucceded(response) {
vm.loadingRegister = false;
vm.registerButtonText = "";
vm.isRegistered = true;
vm.isError = false;
vm.errorMessage = "";
$scope.sForm.$setPristine();
$('html, body').animate({ scrollTop: $("#registration").offset().top - 30 }, 1000);
}
function loadDiscounts() {
var url = '/api/discounts/count/3';
vm.cacheKey4 = url;
//sessionStorage.removeItem(vm.cacheKey4);
if (sessionStorage.getItem(vm.cacheKey4) == null) {
apiService.get(url, null,
loadDiscountsCompleted,
loadFailed
);
}
else {
loadDiscountsCompleted(JSON.parse(sessionStorage.getItem(vm.cacheKey4)));
}
}
function loadDiscountsCompleted(result) {
if (sessionStorage.getItem(vm.cacheKey4) == null) sessionStorage.setItem(vm.cacheKey4, JSON.stringify(result));
vm.enabledDiscounts = result.data.count;
vm.loadingProduct = false;
}
function registerFailed(response) {
vm.loadingRegister = false;
vm.registerButtonText = "Register";
vm.isError = true;
vm.errorMessage = response.data.Message;
}
function loadMetaData() {
ngMeta.setTitle(vm.conference.Title);
ngMeta.setTag('description', vm.conference.Title);
}
loadConferenceProducts();
loadProducts();
setTimeout(function () {
$('.image-link').magnificPopup({ type: 'image' });
}, 250);
//show side panel on google embed map
setTimeout(function () { $('div.i4ewOd-pzNkMb-ornU0b-b0t70b-Bz112c').click(); }, 3000);
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('unconfiscatable2019GalleryCtrl', unconfiscatable2019GalleryCtrl);
unconfiscatable2019GalleryCtrl.$inject = ['$scope', '$rootScope'];
function unconfiscatable2019GalleryCtrl($scope, $rootScope) {
$rootScope.$broadcast("updatePageLocation", "conferenceUnconfiscatable");
$scope.pageClass = 'page-conference';
var vm = this;
setTimeout(function () {
$('.image-link').magnificPopup({ type: 'image' });
}, 250);
scrollToTop();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('pokerCtrl', pokerCtrl);
pokerCtrl.$inject = ['$scope', '$rootScope', '$filter', '$sce', 'ngMeta', 'apiService', 'notificationService'];
function pokerCtrl($scope, $rootScope, $filter, $sce, ngMeta, apiService, notificationService) {
$rootScope.$broadcast("updatePageLocation", "pokertourney");
$scope.pageClass = 'page-conference';
var vm = this;
vm.title = 'poker-2024';
vm.trust = $sce.trustAsHtml;
vm.pageContent = $scope.$parent.getPageContent("PokerTourney");
vm.trustSrc = function (src) {
return $sce.trustAsResourceUrl(src);
}
vm.submitButtonText = "Submit";
vm.conference = {};
vm.conferenceProducts = [];
vm.conferenceProductsForPurchase = [];
vm.seatsLeft = 0;
vm.isSoldOut = false;
vm.loadingProduct = true;
vm.loadingRegister = false;
vm.isRegistered = false;
vm.registerButtonText = "Register";
vm.isError = false;
vm.errorMessage = "";
vm.cacheKey = "";
vm.customer = {
CurrencyTypeID: 1,
ProductId: null
};
vm.showCouponCode = function () {
$("#couponCode").slideToggle("slow");
};
vm.register = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
vm.loadingRegister = true;
vm.registerButtonText = "Please Wait...";
apiService.post('/api/orders/new', vm.customer,
registerSucceded,
registerFailed);
};
function registerSucceded(response) {
vm.loadingRegister = false;
vm.registerButtonText = "";
if (response.data.redirectUrl != null) {
//redirect to payment
window.location.href = response.data.redirectUrl;
}
else {
vm.isRegistered = true;
$scope.sForm.$setPristine();
$('html, body').animate({ scrollTop: $("#registration").offset().top - 30 }, 1000);
}
}
function registerFailed(response) {
vm.loadingRegister = false;
vm.isError = true;
vm.errorMessage = response.data.Message;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
function loadConferenceProducts() {
var url = '/api/conferenceproducts/title/' + vm.title;
vm.cacheKey = url;
//sessionStorage.removeItem(vm.cacheKey);
if (sessionStorage.getItem(vm.cacheKey) == null) {
apiService.get(url, null,
loadConferenceProductsCompleted,
loadFailed
);
}
else {
loadConferenceProductsCompleted(JSON.parse(sessionStorage.getItem(vm.cacheKey)));
}
}
function loadConferenceProductsCompleted(result) {
if (sessionStorage.getItem(vm.cacheKey) == null) sessionStorage.setItem(vm.cacheKey, JSON.stringify(result));
vm.conferenceProducts = result.data;
if (vm.conferenceProducts.length > 0) {
vm.conference = vm.conferenceProducts[0].Conference;
loadMetaData();
//get conference products that are not sold out
vm.conferenceProductsForPurchase = vm.conferenceProducts.filter(function (entry) {
return (entry.IsSoldOut == false);
});
if (vm.conferenceProductsForPurchase.length > 0) {
vm.seatsLeft = vm.conferenceProducts[0].SeatsLeft;
vm.customer.ConferenceProductId = vm.conferenceProducts[0].ID;
}
else {
vm.isSoldOut = true;
}
vm.loadingProduct = false;
//loadDiscounts();
}
}
function loadMetaData() {
ngMeta.setTitle(vm.conference.Title);
ngMeta.setTag('description', vm.conference.Title);
}
$scope.$on('pageContentLoaded', function (event, data) {
vm.pageContent = $scope.$parent.getPageContent("PokerTourney");
});
loadConferenceProducts();
scrollToTop();
loadMasks();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('pokerTourneyCtrl', pokerTourneyCtrl);
pokerTourneyCtrl.$inject = ['$scope', '$rootScope', '$filter', '$sce', 'ngMeta', 'apiService', 'notificationService'];
function pokerTourneyCtrl($scope, $rootScope, $filter, $sce, ngMeta, apiService, notificationService) {
$rootScope.$broadcast("updatePageLocation", "pokertourney");
$scope.pageClass = 'page-conference';
var vm = this;
vm.title = 'poker-2024';
vm.trust = $sce.trustAsHtml;
vm.pageContent = $scope.$parent.getPageContent("PokerTourney");
vm.trustSrc = function (src) {
return $sce.trustAsResourceUrl(src);
}
vm.submitButtonText = "Submit";
vm.conference = {};
vm.conferenceProducts = [];
vm.conferenceProductsForPurchase = [];
vm.seatsLeft = 0;
vm.isSoldOut = false;
vm.loadingProduct = true;
vm.loadingRegister = false;
vm.isRegistered = false;
vm.registerButtonText = "Register";
vm.isError = false;
vm.errorMessage = "";
vm.cacheKey = "";
vm.customer = {
CurrencyTypeID: 1,
ProductId: null
};
vm.showCouponCode = function () {
$("#couponCode").slideToggle("slow");
};
vm.register = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
vm.loadingRegister = true;
vm.registerButtonText = "Please Wait...";
apiService.post('/api/orders/new', vm.customer,
registerSucceded,
registerFailed);
};
function registerSucceded(response) {
vm.loadingRegister = false;
vm.registerButtonText = "";
if (response.data.redirectUrl != null) {
//redirect to payment
window.location.href = response.data.redirectUrl;
}
else {
vm.isRegistered = true;
$scope.sForm.$setPristine();
$('html, body').animate({ scrollTop: $("#registration").offset().top - 30 }, 1000);
}
}
function registerFailed(response) {
vm.loadingRegister = false;
vm.isError = true;
vm.errorMessage = response.data.Message;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
function loadConferenceProducts() {
var url = '/api/conferenceproducts/title/' + vm.title;
vm.cacheKey = url;
//sessionStorage.removeItem(vm.cacheKey);
if (sessionStorage.getItem(vm.cacheKey) == null) {
apiService.get(url, null,
loadConferenceProductsCompleted,
loadFailed
);
}
else {
loadConferenceProductsCompleted(JSON.parse(sessionStorage.getItem(vm.cacheKey)));
}
}
function loadConferenceProductsCompleted(result) {
if (sessionStorage.getItem(vm.cacheKey) == null) sessionStorage.setItem(vm.cacheKey, JSON.stringify(result));
vm.conferenceProducts = result.data;
if (vm.conferenceProducts.length > 0) {
vm.conference = vm.conferenceProducts[0].Conference;
loadMetaData();
//get conference products that are not sold out
vm.conferenceProductsForPurchase = vm.conferenceProducts.filter(function (entry) {
return (entry.IsSoldOut == false);
});
if (vm.conferenceProductsForPurchase.length > 0) {
vm.seatsLeft = vm.conferenceProducts[0].SeatsLeft;
vm.customer.ConferenceProductId = vm.conferenceProducts[0].ID;
}
else {
vm.isSoldOut = true;
}
vm.loadingProduct = false;
//loadDiscounts();
}
}
function loadMetaData() {
ngMeta.setTitle(vm.conference.Title);
ngMeta.setTag('description', vm.conference.Title);
}
$scope.$on('pageContentLoaded', function (event, data) {
vm.pageContent = $scope.$parent.getPageContent("PokerTourney");
});
loadConferenceProducts();
scrollToTop();
loadMasks();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('test_pokerTourneyCtrl', test_pokerTourneyCtrl);
test_pokerTourneyCtrl.$inject = ['$scope', '$rootScope', '$filter', '$sce', 'ngMeta', 'apiService', 'notificationService'];
function test_pokerTourneyCtrl($scope, $rootScope, $filter, $sce, ngMeta, apiService, notificationService) {
$rootScope.$broadcast("updatePageLocation", "admin-pokertourney");
$scope.pageClass = 'page-conference';
var vm = this;
vm.title = 'poker-2022';
vm.trust = $sce.trustAsHtml;
vm.pageContent = $scope.$parent.getPageContent("PokerTourney");
vm.trustSrc = function (src) {
return $sce.trustAsResourceUrl(src);
}
vm.submitButtonText = "Submit";
vm.conference = {};
vm.conferenceProducts = [];
vm.conferenceProductsForPurchase = [];
vm.seatsLeft = 0;
vm.isSoldOut = false;
vm.loadingProduct = true;
vm.loadingRegister = false;
vm.isRegistered = false;
vm.registerButtonText = "Register";
vm.isError = false;
vm.errorMessage = "";
vm.cacheKey = "";
vm.customer = {
CurrencyTypeID: 1,
ProductId: null
};
$scope.vidEnded = function () {
alert('vid ended');
}
vm.showCouponCode = function () {
$("#couponCode").slideToggle("slow");
};
vm.register = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
vm.loadingRegister = true;
vm.registerButtonText = "Please Wait...";
apiService.post('/api/orders/new', vm.customer,
registerSucceded,
registerFailed);
};
function setupVideo() {
// get video
var video = $("#myVideo");//document.getElementById('myVideo')
// Play the video, this is optional
//video.play();
// Add a listener to this video, so that when the video ends, the video is "hidden".
//video.addEventListener('ended', function () {
// // hide video
// video.style.display = "none";
//})
};
function registerSucceded(response) {
vm.loadingRegister = false;
vm.registerButtonText = "";
if (response.data.redirectUrl != null) {
//redirect to payment
window.location.href = response.data.redirectUrl;
}
else {
vm.isRegistered = true;
$scope.sForm.$setPristine();
$('html, body').animate({ scrollTop: $("#registration").offset().top - 30 }, 1000);
}
}
function registerFailed(response) {
vm.loadingRegister = false;
vm.isError = true;
vm.errorMessage = response.data.Message;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
function loadConferenceProducts() {
var url = '/api/conferenceproducts/title/' + vm.title;
vm.cacheKey = url;
//sessionStorage.removeItem(vm.cacheKey);
if (sessionStorage.getItem(vm.cacheKey) == null) {
apiService.get(url, null,
loadConferenceProductsCompleted,
loadFailed
);
}
else {
loadConferenceProductsCompleted(JSON.parse(sessionStorage.getItem(vm.cacheKey)));
}
}
function loadConferenceProductsCompleted(result) {
if (sessionStorage.getItem(vm.cacheKey) == null) sessionStorage.setItem(vm.cacheKey, JSON.stringify(result));
vm.conferenceProducts = result.data;
if (vm.conferenceProducts.length > 0) {
vm.conference = vm.conferenceProducts[0].Conference;
loadMetaData();
//get conference products that are not sold out
vm.conferenceProductsForPurchase = vm.conferenceProducts.filter(function (entry) {
return (entry.IsSoldOut == false);
});
if (vm.conferenceProductsForPurchase.length > 0) {
vm.seatsLeft = vm.conferenceProducts[0].SeatsLeft;
vm.customer.ConferenceProductId = vm.conferenceProducts[0].ID;
}
else {
vm.isSoldOut = true;
}
vm.loadingProduct = false;
//loadDiscounts();
}
}
function loadMetaData() {
ngMeta.setTitle(vm.conference.Title);
ngMeta.setTag('description', vm.conference.Title);
}
$scope.$on('pageContentLoaded', function (event, data) {
vm.pageContent = $scope.$parent.getPageContent("PokerTourney");
});
setupVideo();
loadConferenceProducts();
scrollToTop();
loadMasks();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('carnivoryCtrl', carnivoryCtrl);
carnivoryCtrl.$inject = ['$scope', '$rootScope', '$filter', '$sce', 'ngMeta', 'apiService', 'notificationService'];
function carnivoryCtrl($scope, $rootScope, $filter, $sce, ngMeta, apiService, notificationService) {
$rootScope.$broadcast("updatePageLocation", "carnivory");
$scope.pageClass = 'page-conference';
var vm = this;
vm.title = 'unconfiscatable-2024';
vm.trust = $sce.trustAsHtml;
vm.pageContent = $scope.$parent.getPageContent("Carnivore");
vm.trustSrc = function (src) {
return $sce.trustAsResourceUrl(src);
}
vm.submitButtonText = "Submit";
vm.showRegistration = true;
vm.conference = {};
vm.conferenceProducts = [];
vm.conferenceProductsForPurchase = [];
vm.seatsLeft = 0;
vm.isSoldOut = false;
vm.loadingProduct = true;
vm.loadingRegister = false;
vm.isRegistered = false;
vm.registerButtonText = "Register";
vm.isError = false;
vm.errorMessage = "";
vm.cacheKey = "";
vm.customer = {
CurrencyTypeID: 1,
ProductId: null
};
vm.showCouponCode = function () {
$("#couponCode").slideToggle("slow");
};
vm.selectConferenceProduct = function (conferenceProduct) {
var bInCart = "";
if (cartLS.get(conferenceProduct.ID) == undefined) {
var items = cartLS.list();
//console.log(items);
if (conferenceProduct.Title.includes("VIP")) {
//need to not allow VIP + Event or VIP + Carnivory
for (var key in items) {
var item = items[key];
if (item.name.includes("Ticket")) {
bInCart = "Event Ticket Already Selected";
break;
}
}
}
if (conferenceProduct.Title.includes("Ticket")) {
//need to not allow Event + VIP
for (var key in items) {
var item = items[key];
if (item.name.includes("VIP")) {
bInCart = "VIP Already Selected";
break;
}
}
}
//if (conferenceProduct.Title.includes("Carnivory")) {
// //need to not allow Event + VIP
// for (var key in items) {
// var item = items[key];
// if (item.name.includes("VIP")) {
// bInCart = "VIP Already Selected";
// break;
// }
// }
//}
}
else {
bInCart = "Item Already In Cart";
}
if (bInCart !== "") {
notificationService.displayInfo(bInCart);
}
else {
cartLS.add({ id: conferenceProduct.ID, name: conferenceProduct.Title, price: conferenceProduct.Price, usdPrice: conferenceProduct.PriceFiat });
// cartLS.add({ id: 2, name: "Product 2", price: 100 }, 2);
vm.cartTotal = cartLS.total();
$rootScope.$broadcast("updateCartTotal", cartLS.total());
notificationService.displaySuccess('Successfully Added to Cart');
}
//console.log(cartLS.get(conferenceProduct.ID));
};
vm.register = function (sForm) {
//if (sForm.$invalid) {
// angular.forEach(sForm.$error, function (field) {
// angular.forEach(field, function (errorField) {
// errorField.$setDirty();
// })
// });
// return;
//}
//vm.loadingRegister = true;
//vm.registerButtonText = "Please Wait...";
//apiService.post('/api/orders/new', vm.customer,
// registerSucceded,
// registerFailed);
};
//function registerSucceded(response) {
// vm.loadingRegister = false;
// vm.registerButtonText = "";
// if (response.data.redirectUrl != null) {
// //redirect to payment
// window.location.href = response.data.redirectUrl;
// }
// else {
// vm.isRegistered = true;
// $scope.sForm.$setPristine();
// $('html, body').animate({ scrollTop: $("#registration").offset().top - 30 }, 1000);
// }
//}
//function registerFailed(response) {
// vm.loadingRegister = false;
// vm.registerButtonText = "Purchase Indicator";
// vm.isError = true;
// vm.errorMessage = response.data.Message;
//}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
function loadConferenceProducts() {
var url = '/api/conferenceproducts/title/' + vm.title;
vm.cacheKey = url;
//sessionStorage.removeItem(vm.cacheKey);
if (sessionStorage.getItem(vm.cacheKey) == null) {
apiService.get(url, null,
loadConferenceProductsCompleted,
loadFailed
);
}
else {
loadConferenceProductsCompleted(JSON.parse(sessionStorage.getItem(vm.cacheKey)));
}
}
function loadRegistration() {
if (sessionStorage.getItem("presale") != null) {
//show registration form if presale mateches year
var currYear = (new Date().getFullYear() + 1).toString(); // returns the current year
var year = sessionStorage.getItem("presale").toString();
if (currYear === year) {
vm.showRegistration = true;
//alert(vm.showRegistration);
}
}
}
function loadConferenceProductsCompleted(result) {
if (sessionStorage.getItem(vm.cacheKey) == null) sessionStorage.setItem(vm.cacheKey, JSON.stringify(result));
vm.conferenceProducts = result.data;
if (vm.conferenceProducts.length > 0) {
vm.conference = vm.conferenceProducts[0].Conference;
loadMetaData();
//get conference products that are not sold out
vm.conferenceProductsForPurchase = vm.conferenceProducts.filter(function (entry) {
return (entry.IsSoldOut == false);
});
if (vm.conferenceProductsForPurchase.length > 0) {
vm.seatsLeft = vm.conferenceProducts[0].SeatsLeft;
vm.customer.ConferenceProductId = vm.conferenceProducts[0].ID;
}
else {
vm.isSoldOut = true;
}
vm.loadingProduct = false;
//loadDiscounts();
}
}
function loadMetaData() {
ngMeta.setTitle(vm.conference.Title);
ngMeta.setTag('description', vm.conference.Title);
}
$scope.$on('pageContentLoaded', function (event, data) {
vm.pageContent = $scope.$parent.getPageContent("Carnivore");
});
loadConferenceProducts();
loadRegistration();
scrollToTop();
loadMasks();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('pinballTourneyCtrl', pinballTourneyCtrl);
pinballTourneyCtrl.$inject = ['$scope', '$rootScope', '$filter', '$sce', 'ngMeta', 'apiService', 'notificationService'];
function pinballTourneyCtrl($scope, $rootScope, $filter, $sce, ngMeta, apiService, notificationService) {
$rootScope.$broadcast("updatePageLocation", "pinballtourney");
$scope.pageClass = 'page-conference';
var vm = this;
vm.title = 'pinball-tournament-2020';
vm.trust = $sce.trustAsHtml;
vm.pageContent = $scope.$parent.getPageContent("PinballTourney");
vm.trustSrc = function (src) {
return $sce.trustAsResourceUrl(src);
}
vm.submitButtonText = "Submit";
vm.conference = {};
vm.conferenceProducts = [];
vm.conferenceProductsForPurchase = [];
vm.seatsLeft = 0;
vm.isSoldOut = false;
vm.loadingProduct = true;
vm.loadingRegister = false;
vm.isRegistered = false;
vm.registerButtonText = "Register";
vm.isError = false;
vm.errorMessage = "";
vm.cacheKey = "";
vm.cacheKey2 = "";
vm.customer = {
CurrencyTypeID: "",
ProductId: null
};
vm.showCouponCode = function () {
$("#couponCode").slideToggle("slow");
};
vm.register = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
vm.loadingRegister = true;
vm.registerButtonText = "Please Wait...";
apiService.post('/api/orders/new', vm.customer,
registerSucceded,
registerFailed);
};
function registerSucceded(response) {
vm.loadingRegister = false;
vm.registerButtonText = "";
vm.isRegistered = true;
vm.isError = false;
vm.errorMessage = "";
$scope.sForm.$setPristine();
$('html, body').animate({ scrollTop: $("#registration").offset().top - 30 }, 1000);
}
function registerFailed(response) {
vm.loadingRegister = false;
vm.registerButtonText = "Purchase Indicator";
vm.isError = true;
vm.errorMessage = response.data.Message;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
function loadConferenceProducts() {
var url = '/api/conferenceproducts/title/' + vm.title;
vm.cacheKey = url;
//sessionStorage.removeItem(vm.cacheKey);
if (sessionStorage.getItem(vm.cacheKey) == null) {
apiService.get(url, null,
loadConferenceProductsCompleted,
loadFailed
);
}
else {
loadConferenceProductsCompleted(JSON.parse(sessionStorage.getItem(vm.cacheKey2)));
}
}
function loadConferenceProductsCompleted(result) {
if (sessionStorage.getItem(vm.cacheKey2) == null) sessionStorage.setItem(vm.cacheKey2, JSON.stringify(result));
vm.conferenceProducts = result.data;
if (vm.conferenceProducts.length > 0) {
vm.conference = vm.conferenceProducts[0].Conference;
loadMetaData();
//get conference products that are not sold out
vm.conferenceProductsForPurchase = vm.conferenceProducts.filter(function (entry) {
return (entry.IsSoldOut == false);
});
if (vm.conferenceProductsForPurchase.length > 0) {
vm.seatsLeft = vm.conferenceProducts[0].SeatsLeft;
vm.customer.ConferenceProductId = vm.conferenceProducts[0].ID;
}
else {
vm.isSoldOut = true;
}
vm.loadingProduct = false;
//loadDiscounts();
}
}
function loadMetaData() {
ngMeta.setTitle(vm.conference.Title);
ngMeta.setTag('description', vm.conference.Title);
}
$scope.$on('pageContentLoaded', function (event, data) {
vm.pageContent = $scope.$parent.getPageContent("PinballTourney");
});
loadConferenceProducts();
scrollToTop();
loadMasks();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('scammyAwardsCtrl', scammyAwardsCtrl);
scammyAwardsCtrl.$inject = ['$scope', '$rootScope', '$filter', '$sce', 'ngMeta', 'apiService', 'notificationService'];
function scammyAwardsCtrl($scope, $rootScope, $filter, $sce, ngMeta, apiService, notificationService) {
$rootScope.$broadcast("updatePageLocation", "scammyawards");
$scope.pageClass = 'page-conference';
var vm = this;
vm.title = 'scammies-2022';
vm.trust = $sce.trustAsHtml;
vm.pageContent = $scope.$parent.getPageContent("ScammyAwards");
vm.trustSrc = function (src) {
return $sce.trustAsResourceUrl(src);
}
vm.submitButtonText = "Submit";
vm.conference = {};
vm.conferenceProducts = [];
vm.conferenceProductsForPurchase = [];
vm.seatsLeft = 0;
vm.isSoldOut = false;
vm.loadingProduct = true;
vm.loadingRegister = false;
vm.isRegistered = false;
vm.registerButtonText = "Register";
vm.isError = false;
vm.errorMessage = "";
vm.cacheKey = "";
vm.customer = {
CurrencyTypeID: 1,
ProductId: null
};
vm.showCouponCode = function () {
$("#couponCode").slideToggle("slow");
};
vm.register = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
vm.loadingRegister = true;
vm.registerButtonText = "Please Wait...";
apiService.post('/api/orders/new', vm.customer,
registerSucceded,
registerFailed);
};
function registerSucceded(response) {
vm.loadingRegister = false;
vm.registerButtonText = "";
if (response.data.redirectUrl != null) {
//redirect to payment
window.location.href = response.data.redirectUrl;
}
else {
vm.isRegistered = true;
$scope.sForm.$setPristine();
$('html, body').animate({ scrollTop: $("#registration").offset().top - 30 }, 1000);
}
}
function registerFailed(response) {
vm.loadingRegister = false;
vm.isError = true;
vm.errorMessage = response.data.Message;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
function loadConferenceProducts() {
var url = '/api/conferenceproducts/title/' + vm.title;
vm.cacheKey = url;
//sessionStorage.removeItem(vm.cacheKey);
if (sessionStorage.getItem(vm.cacheKey) == null) {
apiService.get(url, null,
loadConferenceProductsCompleted,
loadFailed
);
}
else {
loadConferenceProductsCompleted(JSON.parse(sessionStorage.getItem(vm.cacheKey)));
}
}
function loadConferenceProductsCompleted(result) {
if (sessionStorage.getItem(vm.cacheKey) == null) sessionStorage.setItem(vm.cacheKey, JSON.stringify(result));
vm.conferenceProducts = result.data;
if (vm.conferenceProducts.length > 0) {
vm.conference = vm.conferenceProducts[0].Conference;
loadMetaData();
//get conference products that are not sold out
vm.conferenceProductsForPurchase = vm.conferenceProducts.filter(function (entry) {
return (entry.IsSoldOut == false);
});
if (vm.conferenceProductsForPurchase.length > 0) {
vm.seatsLeft = vm.conferenceProducts[0].SeatsLeft;
vm.customer.ConferenceProductId = vm.conferenceProducts[0].ID;
}
else {
vm.isSoldOut = true;
}
vm.loadingProduct = false;
//loadDiscounts();
}
}
function loadMetaData() {
ngMeta.setTitle(vm.conference.Title);
ngMeta.setTag('description', vm.conference.Title);
}
$scope.$on('pageContentLoaded', function (event, data) {
vm.pageContent = $scope.$parent.getPageContent("ScammyAwards");
});
loadConferenceProducts();
scrollToTop();
loadMasks();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('axeThrowingCtrl', axeThrowingCtrl);
axeThrowingCtrl.$inject = ['$scope', '$rootScope', '$filter', '$sce', 'ngMeta', 'apiService', 'notificationService'];
function axeThrowingCtrl($scope, $rootScope, $filter, $sce, ngMeta, apiService, notificationService) {
$rootScope.$broadcast("updatePageLocation", "axethrowing");
$scope.pageClass = 'page-conference';
var vm = this;
vm.title = 'axe-throwing-2022';
vm.trust = $sce.trustAsHtml;
vm.pageContent = $scope.$parent.getPageContent("AxeThrowing");
vm.trustSrc = function (src) {
return $sce.trustAsResourceUrl(src);
}
vm.submitButtonText = "Submit";
vm.conference = {};
vm.conferenceProducts = [];
vm.conferenceProductsForPurchase = [];
vm.seatsLeft = 0;
vm.isSoldOut = false;
vm.loadingProduct = true;
vm.loadingRegister = false;
vm.isRegistered = false;
vm.registerButtonText = "Register";
vm.isError = false;
vm.errorMessage = "";
vm.cacheKey = "";
vm.cacheKey2 = "";
vm.customer = {
CurrencyTypeID: "",
ProductId: null
};
vm.showCouponCode = function () {
$("#couponCode").slideToggle("slow");
};
vm.register = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
vm.loadingRegister = true;
vm.registerButtonText = "Please Wait...";
apiService.post('/api/orders/new', vm.customer,
registerSucceded,
registerFailed);
};
function registerSucceded(response) {
vm.loadingRegister = false;
vm.registerButtonText = "";
vm.isRegistered = true;
vm.isError = false;
vm.errorMessage = "";
$scope.sForm.$setPristine();
$('html, body').animate({ scrollTop: $("#registration").offset().top - 30 }, 1000);
}
function registerFailed(response) {
vm.loadingRegister = false;
vm.registerButtonText = "Purchase Indicator";
vm.isError = true;
vm.errorMessage = response.data.Message;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
function loadConferenceProducts() {
var url = '/api/conferenceproducts/title/' + vm.title;
vm.cacheKey = url;
//sessionStorage.removeItem(vm.cacheKey);
if (sessionStorage.getItem(vm.cacheKey) == null) {
apiService.get(url, null,
loadConferenceProductsCompleted,
loadFailed
);
}
else {
loadConferenceProductsCompleted(JSON.parse(sessionStorage.getItem(vm.cacheKey2)));
}
}
function loadConferenceProductsCompleted(result) {
if (sessionStorage.getItem(vm.cacheKey2) == null) sessionStorage.setItem(vm.cacheKey2, JSON.stringify(result));
vm.conferenceProducts = result.data;
if (vm.conferenceProducts.length > 0) {
vm.conference = vm.conferenceProducts[0].Conference;
loadMetaData();
//get conference products that are not sold out
vm.conferenceProductsForPurchase = vm.conferenceProducts.filter(function (entry) {
return (entry.IsSoldOut == false);
});
if (vm.conferenceProductsForPurchase.length > 0) {
vm.seatsLeft = vm.conferenceProducts[0].SeatsLeft;
vm.customer.ConferenceProductId = vm.conferenceProducts[0].ID;
}
else {
vm.isSoldOut = true;
}
vm.loadingProduct = false;
//loadDiscounts();
}
}
function loadMetaData() {
ngMeta.setTitle(vm.conference.Title);
ngMeta.setTag('description', vm.conference.Title);
}
$scope.$on('pageContentLoaded', function (event, data) {
vm.pageContent = $scope.$parent.getPageContent("axeThrowing");
});
loadConferenceProducts();
scrollToTop();
loadMasks();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('celebrityFormCtrl', celebrityFormCtrl);
celebrityFormCtrl.$inject = ['$scope', '$rootScope', '$filter', '$sce', 'apiService', 'notificationService'];
function celebrityFormCtrl($scope, $rootScope, $filter, $sce, apiService, notificationService) {
$rootScope.$broadcast("updatePageLocation", "celebrityform");
$scope.pageClass = 'page-conference';
var vm = this;
vm.trust = $sce.trustAsHtml;
vm.pageContent = $scope.$parent.getPageContent("CelebrityPoker");
vm.trustSrc = function (src) {
return $sce.trustAsResourceUrl(src);
}
vm.isCompleted = false;
vm.loading = false;
vm.submitButtonText = "Submit";
vm.seatsLeft = 0;
vm.isError = false;
vm.errorMessage = "";
vm.message = {
CreatedDate: new Date(),
Contacted: false
};
vm.submit = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
//if (!$scope.captchaValid) return;
vm.loading = true;
vm.submitButtonText = "Please Wait...";
apiService.post('/api/emails/celebritypoker', vm.message,
submitSucceded,
submitFailed);
};
function submitSucceded(response) {
vm.loading = false;
vm.submitButtonText = "Submit";
vm.isCompleted = true;
vm.isError = false;
vm.errorMessage = "";
vm.customer = response.data;
$scope.sForm2.$setPristine();
}
function submitFailed(response) {
vm.loading = false;
vm.submitButtonText = "Submit";
vm.isError = true;
vm.errorMessage = response.data.Message;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
function loadProducts() {
var url = '/api/products/public';
vm.cacheKey = url;
//sessionStorage.removeItem(vm.cacheKey);
if (sessionStorage.getItem(vm.cacheKey) == null) {
apiService.get(url, null,
loadProductsCompleted,
loadFailed
);
}
else {
loadProductsCompleted(JSON.parse(sessionStorage.getItem(vm.cacheKey)));
}
}
function loadProductsCompleted(result) {
if (sessionStorage.getItem(vm.cacheKey) == null) sessionStorage.setItem(vm.cacheKey, JSON.stringify(result));
var products = result.data;
vm.products = products.filter(function (entry) {
return (entry.Title.indexOf('Celebrity Poker') > -1);
});
var product = vm.products[0];
vm.seatsLeft = product.SeatsLeft - 10;
vm.isSoldOut = product.IsSoldOut;
vm.loadingProduct = false;
}
$scope.$on('pageContentLoaded', function (event, data) {
vm.pageContent = $scope.$parent.getPageContent("CelebrityPoker");
});
loadProducts();
scrollToTop();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('unsubscribeCtrl', unsubscribeCtrl);
unsubscribeCtrl.$inject = ['$scope', '$rootScope', '$location', '$http', '$routeParams', 'apiService', 'notificationService'];
function unsubscribeCtrl($scope, $rootScope, $location, $http, $routeParams, apiService, notificationService) {
$scope.pageClass = 'page-unsubscribe';
var vm = this;
vm.isLoading = true;
vm.isValidated = false;
vm.isComplete = false;
vm.errorMessage = "";
vm.isError = false;
vm.email = "";
vm.unsubscribe = function () {
if (vm.isValidated && vm.email.length > 0) {
unsubscribe();
}
}
function unsubscribe() {
vm.isLoading = true;
var url = '/api/customers/unsubscribe/' + $routeParams.cid + '/' + $routeParams.uid + '/' + vm.email;
apiService.put(url, null,
unsubscribeCompleted,
unsubscribeFailed);
}
function unsubscribeCompleted(result) {
vm.isLoading = false;
vm.isComplete = true;
}
function unsubscribeFailed(response) {
vm.isLoading = false;
vm.isError = true;
vm.errorMessage = response.data.Message;
}
function getCustomerCompleted(result) {
vm.errorMessage = "";
vm.isError = false;
vm.isLoading = false;
vm.isValidated = true;
}
function getCustomerFailed(response) {
vm.isLoading = false;
vm.isError = true;
vm.errorMessage = response.data.Message;
}
function getCustomer() {
var url = '/api/customers/unsubscribe/verify/' + $routeParams.cid + '/' + $routeParams.uid;
apiService.get(url, null,
getCustomerCompleted,
getCustomerFailed
);
}
getCustomer();
}
})(angular.module('common.core'));;
(function (app) {
'use strict';
app.controller('adminCtrl', adminCtrl);
adminCtrl.$inject = ['$scope', '$rootScope', '$timeout', '$http', 'apiService', 'notificationService'];
function adminCtrl($scope, $rootScope, $timeout, $http, apiService, notificationService) {
$scope.pageClass = 'page-admin-home';
$rootScope.$broadcast("updatePageLocation", "admin");
$rootScope.adminTimer = null;
var vm = this;
vm.pageContent = [];
vm.isLoading = true;
vm.logout = $scope.$parent.logout;
vm.user = $scope.$parent.loggedUser;
vm.username = $scope.$parent.loggedUser.username;
vm.counter = 5;
vm.onTimeout = function () {
vm.counter--;
mytimeout = $timeout(vm.onTimeout, 60000);
}
var mytimeout = $timeout(vm.onTimeout, 60000);
function loadData() {
var url = '/api/admin/home';
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function loadKey() {
var url = '/api/admin/genkey';
apiService.get(url, null,
loadKeyCompleted,
loadFailed
);
}
function loadCompleted(result) {
vm.pageContent = result.data;
vm.isLoading = false;
//$rootScope.adminTimer = $timeout(reloadData, 300000);
}
function loadKeyCompleted(result) {
console.info(result);
}
function loadFailed(response) {
notificationService.displayError(response.data);
vm.isLoading = false;
}
function reloadData() {
if ($scope.pageClass == 'page-admin-home') {
vm.counter = 5;
loadData();
console.info('reloaded');
}
}
if (vm.username == 'customer') {
vm.logout();
}
else {
loadData();
//loadKey();
}
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('addEventPriceCtrl', addEventPriceCtrl);
addEventPriceCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', '$filter', 'apiService', 'bitcoinService', 'NgTableParams', 'notificationService'];
function addEventPriceCtrl($scope, $rootScope, $routeParams, $location, $modal, $filter, apiService, bitcoinService, NgTableParams, notificationService) {
$scope.pageClass = 'page-admin-add-event-price';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.eventPrice = {
StatusId: "",
CurrencyConversionTypeID: 0,
EventTypeID: "",
Title: "",
Price: "",
Minutes: "",
CreatedDate: new Date()
};
vm.eventPriceStatus = [{ name: 'Status', id: "" }, { name: 'Enabled', id: 1 }, { name: 'Disabled', id: 2 }];
vm.currencyConversionType = [{ name: 'Manual', id: 0 }, { name: 'Peg To BTC', id: 1 }, { name: 'Peg To USD', id: 2 }];
vm.eventTypes = [{ name: 'Event Type', id: "" }, { name: 'Appointment', id: 1 }, { name: 'Consultation', id: 2 }];
vm.allDayTypes = [{ name: 'Select', id: '' }, { name: 'Yes', id: true }, { name: 'No', id: false }];
vm.allDay = '';
vm.create = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
if (vm.allDay == true) vm.eventPrice.Minutes = 0;
if (vm.eventPrice.CurrencyConversionTypeID > 0) {
setPrices();
}
else {
apiService.post('/api/eventprices/add', vm.eventPrice,
createSucceded,
createFailed);
}
};
function setPrices(result) {
bitcoinService.getBTCPrice(
getBTCPriceCompleted,
createFailed,
true
);
}
function getBTCPriceCompleted(result) {
//get price by exchange
var spotPrice = roundUp(result.data, 0);
//convert prices
if (vm.eventPrice.CurrencyConversionTypeID == 1) {
vm.eventPrice.PriceFiat = $filter('btcToUsd')(vm.eventPrice.Price, spotPrice);
}
else if (vm.eventPrice.CurrencyConversionTypeID == 2) {
vm.eventPrice.Price = $filter('usdToBtc')(vm.eventPrice.PriceFiat, spotPrice);;
}
//add event price
apiService.post('/api/eventprices/add', vm.eventPrice,
createSucceded,
createFailed);
}
function createSucceded(response) {
notificationService.displaySuccess('Successfully added event price');
vm.event = response.data;
sessionStorage.removeItem('/api/eventprices/public');
$location.path('/admin/eventprices');
}
function createFailed(response) {
notificationService.displayError(response.data.Message);
}
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('editEventPriceCtrl', editEventPriceCtrl);
editEventPriceCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', '$filter', 'apiService', 'bitcoinService', 'NgTableParams', 'notificationService'];
function editEventPriceCtrl($scope, $rootScope, $routeParams, $location, $modal, $filter, apiService, bitcoinService, NgTableParams, notificationService) {
$scope.pageClass = 'page-admin-edit-event-price';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.isLoading = true;
vm.eventPrice = {};
vm.eventPriceStatus = [{ name: 'Status', id: '' }, { name: 'Enabled', id: 1 }, { name: 'Disabled', id: 2 }];
vm.currencyConversionType = [{ name: 'Manual', id: 0 }, { name: 'Peg To BTC', id: 1 }, { name: 'Peg To USD', id: 2 }];
vm.exchange = "bitstamp";
vm.eventTypes = [{ name: 'Event Type', id: '' }, { name: 'Appointment', id: 1 }, { name: 'Consultation', id: 2 }];
vm.allDayTypes = [{ name: 'Select', id: '' }, { name: 'Yes', id: true }, { name: 'No', id: false }];
vm.allDay = '';
vm.closePage = function () {
var prevPage = window.location.href;
window.history.go(-1);
setTimeout(function () {
if (window.location.href == prevPage) {
window.close();
}
}, 500);
};
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
if (vm.allDay == true) vm.eventPrice.Minutes = 0;
if (vm.eventPrice.CurrencyConversionTypeID > 0) {
setPrices();
}
else {
update();
}
};
vm.askDelete = function (item) {
var modalHtml = 'Are you sure you want to delete this?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
remove();
});
};
function setPrices(result) {
bitcoinService.getBTCPrice(
getBTCPriceCompleted,
updateFailed,
true
);
}
function getBTCPriceCompleted(result) {
//get price by exchange
var data = result.data.data;
var priceByExchange = data.prices.filter(function (obj) {
return obj.exchange === vm.exchange;
});
//convert prices
var spotPrice = roundUp(priceByExchange[0].price, 0);
if (vm.eventPrice.CurrencyConversionTypeID == 1) {
vm.eventPrice.PriceFiat = $filter('btcToUsd')(vm.eventPrice.Price, spotPrice);
}
else if (vm.eventPrice.CurrencyConversionTypeID == 2) {
vm.eventPrice.Price = $filter('usdToBtc')(vm.eventPrice.PriceFiat, spotPrice);;
}
//update event price
update();
}
function loadData() {
var url = '/api/eventprices/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function update() {
apiService.put('/api/eventprices/update', vm.eventPrice,
updateSucceeded,
updateFailed);
}
function remove() {
var url = '/api/eventprices/delete';
apiService.post(url, vm.eventPrice,
deleteSucceeded,
updateFailed
);
}
function loadCompleted(result) {
vm.eventPrice = result.data;
if (vm.eventPrice.Minutes == 0) vm.allDay = true;
else vm.allDay = false;
vm.isLoading = false;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully updated event price');
$scope.sForm.$setPristine();
sessionStorage.removeItem('/api/eventprices/public');
vm.isLoading = true;
loadData();
}
function deleteSucceeded(response) {
notificationService.displaySuccess('Successfully deleted event price');
$location.path('/admin/eventprices');
}
function updateFailed (response) {
notificationService.displayError(response.data.Message);
}
loadData();
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('eventPricesCtrl', eventPricesCtrl);
eventPricesCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', 'apiService', 'notificationService', 'NgTableParams'];
function eventPricesCtrl($scope, $rootScope, $filter, $location, apiService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-event-prices';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.eventPricesTable = null;
vm.eventPrices = [];
vm.isLoading = true;
vm.filter = "";
vm.statusId = "";
vm.eventTypeId = "";
vm.page = 0;
vm.pageSize = 10;
vm.pagesCount = 0;
vm.totalCount = 0;
vm.eventPriceStatus = [{ name: 'Status', id: "" }, { name: 'Enabled', id: 1 }, { name: 'Disabled', id: 2 }]
vm.eventTypes = [{ name: 'Type', id: "" }, { name: 'Appointment', id: 1 }, { name: 'Consultation', id: 2 }]
vm.edit = function (event) {
var fullPath = window.location.href + '/edit/' + event.ID;
window.open(fullPath, '_blank');
};
vm.pageChanged = function () {
search(vm.page - 1);
};
vm.changePageSize = function () {
vm.page = 0;
search(0);
};
function search(page) {
page = page || 0;
var config = {
params: {
page: page,
pageSize: vm.pageSize,
filter: vm.filter,
statusId: vm.statusId,
eventTypeId: vm.eventTypeId
}
};
apiService.get('/api/eventprices', config,
loadCompleted,
loadFailed);
}
function loadCompleted(result) {
vm.eventPrices = result.data.Items;
vm.pagesCount = result.data.TotalPages;
vm.totalCount = result.data.TotalCount;
var tableParams = { page: 1, count: vm.pageSize, sorting: {} }
vm.eventPricesTable = new NgTableParams(tableParams, { counts: [], total: vm.totalCount, dataset: vm.eventPrices });
vm.isLoading = false;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function watch() {
$scope.$watch('[vm.filter, vm.statusId, vm.eventTypeId]', function (val) {
if (val != '' && val != undefined && val.length > 2) {
search();
} else {
search(0);
}
});
}
watch();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('addEventCtrl', addEventCtrl);
addEventCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', 'apiService', 'bitcoinService', 'NgTableParams', 'notificationService', 'fileUploadService'];
function addEventCtrl($scope, $rootScope, $routeParams, $location, $modal, apiService, bitcoinService, NgTableParams, notificationService, fileUploadService) {
$scope.pageClass = 'page-admin-add-event';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
var eventImage = null;
vm.newRandom = Math.random();
vm.event = {
EventTypeID: 4,
Title: "",
Description: "",
EventURL: "",
Country: "US",
IsImportant: true,
DateStart: new Date(),
DateEnd: new Date(),
CreatedDate: new Date()
};
vm.eventTypes = [{ name: 'Event Type', id: 0 }, { name: 'Appointment', id: 1 }, { name: 'Consultation', id: 2 }, { name: 'Conference', id: 4 }, { name: 'Carnivore', id: 5 }, { name: 'Meet Up', id: 6 }]
vm.datepicker = {};
vm.datepicker2 = {};
vm.dateOptions = {
formatYear: 'yy',
startingDay: 1,
showWeeks: false
};
vm.openDatePicker = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker.opened = true;
};
vm.openDatePicker2 = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker2.opened = true;
};
vm.prepareImage = function ($files) {
eventImage = $files;
};
vm.validateEndDate = function () {
validateDate();
};
vm.addEndDate = function () {
vm.event.DateEnd = vm.event.DateStart;
};
vm.create = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
if (vm.event.EventTypeID != 1 && vm.event.EventTypeID != 2) {
var dateStart = new Date(vm.event.DateStart);
var dateEnd = new Date(vm.event.DateEnd);
dateStart.setHours(8);
dateEnd.setHours(8);
vm.event.DateStart = dateStart;
vm.event.DateEnd = dateEnd;
}
//TODO: Format datestart and dateend fields to just a string .net/sql can recognize 2019-01-31T23:05:16.293
apiService.post('/api/events/add', vm.event,
createSucceded,
createFailed);
};
function createSucceded(response) {
notificationService.displaySuccess('Successfully added event');
sessionStorage.removeItem('/api/events/consultation');
if (eventImage) {
fileUploadService.uploadImage(eventImage, 'event', response.data.eventId, redirectToList);
}
else {
redirectToList();
}
}
function validateDate() {
var dateStart = new Date(formatDate(vm.event.DateStart));
var dateEnd = new Date(formatDate(vm.event.DateEnd));
if (dateEnd < dateStart) {
$scope.sForm.endDate.$setValidity("valid", false);
}
else {
$scope.sForm.endDate.$setValidity("valid", true);
}
}
function redirectToList() {
$location.path('/admin/events');
}
function createFailed(response) {
notificationService.displayError(response.data.Message);
}
function loadRouteParams() {
var date = $routeParams.day;
var time = $routeParams.time;
if (date != 0) {
if (time != 0) {
var dateTime = parseTime(time.toLowerCase(), new Date(date));
vm.event.DateStart = new Date(dateTime);
vm.event.DateEnd = vm.event.DateStart;
}
else {
var dateParsed = new Date(date);
dateParsed.setHours(dateParsed.getHours() + 24);
vm.event.DateStart = dateParsed;
vm.event.DateEnd = vm.event.DateStart;
}
}
}
function formatDate(date) {
var strDate = (date.getMonth() + 1) + '/' + date.getDate() + '/' + date.getFullYear()
return strDate;
}
function parseTime(timeString, d) {
if (timeString == '') return null;
var time = timeString.match(/(\d+)(:(\d\d))?\s*(p?)/i);
if (time == null) return null;
var hours = parseInt(time[1], 10);
if (hours == 12 && !time[4]) {
hours = 0;
}
else {
hours += (hours < 12 && time[4]) ? 12 : 0;
}
d.setHours(hours);
d.setMinutes(parseInt(time[3], 10) || 0);
d.setSeconds(0, 0);
return d;
}
loadRouteParams();
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('editEventCtrl', editEventCtrl);
editEventCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', 'apiService', 'NgTableParams', 'notificationService', 'fileUploadService'];
function editEventCtrl($scope, $rootScope, $routeParams, $location, $modal, apiService, NgTableParams, notificationService, fileUploadService) {
$scope.pageClass = 'page-admin-edit-event';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
var eventImage = null;
vm.newRandom = Math.random();
vm.isLoading = true;
vm.event = {};
vm.eventTypes = [{ name: 'Event Type', id: '' }, { name: 'Appointment', id: 1 }, { name: 'Consultation', id: 2 }, { name: 'Conference', id: 4 }, { name: 'Carnivore', id: 5 }, { name: 'Meet Up', id: 6 }]
vm.datepicker = {};
vm.datepicker2 = {};
vm.dateOptions = {
formatYear: 'yy',
startingDay: 1,
showWeeks: false
};
vm.openDatePicker = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker.opened = true;
};
vm.openDatePicker2 = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker2.opened = true;
};
vm.closePage = function () {
var prevPage = window.location.href;
window.history.go(-1);
setTimeout(function () {
if (window.location.href == prevPage) {
window.close();
}
}, 500);
};
vm.prepareImage = function ($files) {
eventImage = $files;
};
vm.validateEndDate = function () {
validateDate();
};
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
if (vm.event.EventTypeID != 1 && vm.event.EventTypeID != 2) {
var dateStart = new Date(vm.event.DateStart);
var dateEnd = new Date(vm.event.DateEnd);
dateStart.setHours(8);
dateEnd.setHours(8);
vm.event.DateStart = dateStart;
vm.event.DateEnd = dateEnd;
}
//TODO: Format datestart and dateend fields to just a string .net/sql can recognize 2019-01-31T23:05:16.293
if (eventImage) {
fileUploadService.uploadImage(eventImage, 'event', vm.event.ID, eventImageCompleted);
}
else {
update();
}
};
vm.askDelete = function (item) {
var modalHtml = 'Are you sure you want to delete this?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
remove();
});
};
function validateDate() {
var dateStart = new Date(formatDate(vm.event.DateStart));
var dateEnd = new Date(formatDate(vm.event.DateEnd));
if (dateEnd < dateStart) {
$scope.sForm.endDate.$setValidity("valid", false);
}
else {
$scope.sForm.endDate.$setValidity("valid", true);
}
}
function loadData() {
var url = '/api/events/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function update() {
apiService.put('/api/events/update', vm.event,
updateSucceeded,
updateFailed);
}
function remove() {
var url = '/api/events/delete';
apiService.post(url, vm.event,
deleteSucceeded,
updateFailed
);
}
function loadCompleted(result) {
vm.event = result.data;
console.info(vm.event);
loadICal();
vm.isLoading = false;
}
function eventImageCompleted() {
update();
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully updated event');
$scope.sForm.$setPristine();
sessionStorage.removeItem('/api/events/consultation');
vm.isLoading = true;
loadData();
}
function deleteSucceeded(response) {
notificationService.displaySuccess('Successfully deleted event');
$location.path('/admin/events');
}
function updateFailed (response) {
notificationService.displayError(response.data.Message);
}
function formatDate(date) {
var myDate = new Date(date);
var strDate = (myDate.getMonth() + 1) + '/' + myDate.getDate() + '/' + myDate.getFullYear()
return strDate;
}
function loadICal() {
//using clipboard instead of links for outlook and iCalendar
var AustDayLunch = {
start: new Date(vm.event.DateStart),
title: vm.event.Title,
description: vm.event.Description,
location: 'Skype or Google Hangouts'
};
if (vm.event.DateStart != vm.event.DateEnd) AustDayLunch.end = new Date(vm.event.DateEnd);
$('#basicICal').icalendar($.extend({ icons: '../../Content/images/ico/icalendar.png' }, AustDayLunch));
}
loadData();
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('eventsAdminCtrl', eventsAdminCtrl);
eventsAdminCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', 'apiService', 'notificationService', 'NgTableParams'];
function eventsAdminCtrl($scope, $rootScope, $filter, $location, apiService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-events';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.eventsTable = null;
vm.events = [];
vm.isLoading = true;
vm.filter = "";
vm.eventTypeId = "";
vm.page = 0;
vm.pageSize = 10;
vm.pagesCount = 0;
vm.totalCount = 0;
vm.eventTypes = [{ name: 'Event Type', id: "" }, { name: 'Appointment', id: 1 }, { name: 'Consultation', id: 2 }, { name: 'Conference', id: 4 }, { name: 'Carnivore', id: 5 }, { name: 'Meet Up', id: 6 }]
vm.edit = function (event) {
var fullPath = window.location.href + '/edit/' + event.ID;
window.open(fullPath, '_blank');
};
vm.pageChanged = function () {
search(vm.page - 1);
};
vm.changePageSize = function () {
vm.page = 0;
search(0);
};
function search(page) {
page = page || 0;
var config = {
params: {
page: page,
pageSize: vm.pageSize,
filter: vm.filter,
eventTypeId: vm.eventTypeId
}
};
apiService.get('/api/events/', config,
loadCompleted,
loadFailed);
}
function loadCompleted(result) {
vm.events = result.data.Items;
vm.pagesCount = result.data.TotalPages;
vm.totalCount = result.data.TotalCount;
var tableParams = { page: 1, count: vm.pageSize, sorting: {} }
vm.eventsTable = new NgTableParams(tableParams, { counts: [], total: vm.totalCount, dataset: vm.events });
vm.isLoading = false;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function watch() {
$scope.$watch('[vm.filter, vm.eventTypeId]', function (val) {
if (val != '' && val != undefined && val.length > 2) {
search();
} else {
search(0);
}
});
}
watch();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('eventCalendarCtrl', eventCalendarCtrl);
eventCalendarCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', 'apiService', 'notificationService', 'NgTableParams'];
function eventCalendarCtrl($scope, $rootScope, $filter, $location, apiService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-events-calendar';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.events = [];
vm.eventsForCalendar = [];
vm.eventTypes = [{ name: 'Filter', id: "" }, { name: 'Appointment', id: 1 }, { name: 'Consultation', id: 2 }, { name: 'Workshop', id: 3 }, { name: 'Conference', id: 4 }, { name: 'Carnivore', id: 5 }, { name: 'Meet Up', id: 6 }]
vm.workshops = [];
vm.availability = [];
vm.travel = [];
vm.travelTable = null;
vm.isLoading = true;
vm.isWorking = false;
vm.monthSelect = 0;
vm.formData = {
isAvailability: false,
eventTypeId: "",
country: "US",
dateStart: new Date(),
dateEnd: new Date()
}
vm.datepicker = {};
vm.datepicker2 = {};
vm.dateOptions = {
formatYear: 'yy',
startingDay: 1,
showWeeks: false
};
vm.openDatePicker = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker.opened = true;
};
vm.openDatePicker2 = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker2.opened = true;
};
vm.toggleAvailability = function () {
if (vm.formData.isAvailability) loadAvailabilityForCalendar();
else unloadAvailabilityForCalendar();
};
vm.updateAvailability = function () {
vm.isWorking = true;
var availabilityList = [];
$('.cal-day-inmonth').each(function (index, item) {
var date = new Date($(item).find('span').attr('data-cal-date'));
//date.setDate(date.getDate() + 1);
if ($(item).hasClass('available')) {
var availability = {
ID: 0,
EventTypeID: 2,
Date: date,
CreatedDate: new Date()
}
availabilityList.push(availability);
}
});
var year = $('.cal-day-inmonth:first').find('span').attr('data-cal-date').split('-')[0];
var month = $('.cal-day-inmonth:first').find('span').attr('data-cal-date').split('-')[1];
var startDate = new Date(month + "/1/" + year + " 00:00:00");
var data = {
StartDate: startDate,
Availability: availabilityList
};
apiService.put('/api/eventavailability/update/batch', data,
updateAvailabilitySucceeded,
updateFailed);
};
vm.selectUnselectMonth = function () {
if (vm.monthSelect == 0) vm.monthSelect = 1;
else vm.monthSelect = 0;
selectUnselectMonth();
};
vm.filterByEventTypeID = function () {
vm.eventsForCalendar = [];
loadEventsForCalendar();
loadWorkshopsForCalendar();
if (vm.formData.eventTypeId != "") {
vm.eventsForCalendar = vm.eventsForCalendar.filter(function (obj) {
return obj.eventTypeId === vm.formData.eventTypeId;
});
}
loadCalendar();
};
vm.removeEventTravel = function (item) {
var url = '/api/eventtravel/delete';
apiService.post(url, item,
deleteSucceeded,
updateFailed
);
};
vm.create = function (sForm) {
if (vm.formData.dateStart > vm.formData.dateEnd) {
notificationService.displayError("End Date must come after Start Date");
return;
}
create();
};
vm.addEndDate = function () {
vm.formData.dateEnd = vm.formData.dateStart;
};
function create() {
var eventTravel = [];
if (vm.formData.dateStart == vm.formData.dateEnd) {
var travel = {
ID: 0,
Country: vm.formData.country,
Date: vm.formData.dateStart,
CreatedDate: new Date()
}
eventTravel.push(travel);
}
else {
var start = new Date(vm.formData.dateStart);
var end = new Date(vm.formData.dateEnd);
var loop = new Date(start);
while (loop <= end) {
console.info(formatDate(loop));
var travel = {
ID: 0,
Country: vm.formData.country,
Date: formatDate(loop),
CreatedDate: new Date()
}
eventTravel.push(travel);
var newDate = loop.setDate(loop.getDate() + 1);
loop = new Date(newDate);
}
}
var data = {
Travel: eventTravel
};
apiService.put('/api/eventtravel/add/batch', data,
addEventTravelBatchSucceeded,
updateFailed);
}
function addEventTravelBatchSucceeded(result) {
clearForm();
loadEvents();
}
function clearForm() {
vm.formData = {
isAvailability: false,
eventTypeId: "",
country: "US",
dateStart: new Date(),
dateEnd: new Date()
}
}
function updateAvailabilitySucceeded(result) {
unloadAvailabilityForCalendar();
loadAvailability();
sessionStorage.removeItem('/api/eventavailability/consultation');
notificationService.displaySuccess('Successfully updated availability');
}
function loadAvailability() {
vm.availability = [];
apiService.get('/api/eventavailability/all', null,
loadAvailabilityCompleted,
loadFailed);
}
function loadTravel() {
vm.travel = [];
apiService.get('/api/eventtravel/all', null,
loadTravelCompleted,
loadFailed);
}
function loadEvents() {
apiService.get('/api/events/all', null,
loadEventsCompleted,
loadFailed);
}
function loadWorkshops() {
apiService.get('/api/seminars/all', null,
loadWorkshopsCompleted,
loadFailed);
}
function loadEventsForCalendar() {
vm.eventsForCalendar = [];
angular.forEach(vm.events, function (obj, key) {
var dateStart = new Date(obj.DateStart);
var dateEnd = new Date(obj.DateEnd);
if (obj.DateStart == obj.DateEnd) {
dateEnd = dateEnd.setHours(24);
}
else {
dateEnd = Date.parse(dateEnd);
}
var event = {
"id": "e-" + obj.ID,
"title": obj.Title,
"description": obj.Description,
"url": "/admin/events/edit/" + obj.ID,
"country": obj.Country != null ? obj.Country.toLowerCase() : "",
"countryLong": $filter('countryLong')(obj.Country),
"class": "event-" + obj.EventType,
"eventTypeId": obj.EventTypeID,
"allDay": obj.DateStart == obj.DateEnd ? true : false,
"dateStart": formatDate(dateStart),
"timeStart": formatTime(dateStart),
"start": Date.parse(dateStart),
"end": dateEnd
}
vm.eventsForCalendar.push(event);
});
}
function loadWorkshopsForCalendar() {
angular.forEach(vm.workshops, function (obj, key) {
var dateStart = new Date(obj.Date);
var event = {
"id": "w-" + obj.ID,
"title": obj.Location,
"description": obj.IsOnline ? obj.Description : "One day trading course with Tone Vays teaching practical techniques with continuous reference to real & recent examples that demonstrate the advantages of Technical Analysis.",
"url": "/admin/workshops/edit/" + obj.ID,
"country": formatLocation(obj.Location).country,
"countryLong": obj.Location,
"class": "event-Workshop",
"eventTypeId": 3,
"allDay": true,
"dateStart": formatDate(dateStart),
"start": Date.parse(dateStart),
"end": new Date(obj.Date).setHours(24)
}
vm.eventsForCalendar.push(event);
});
}
function loadTravelForCalendar() {
angular.forEach(vm.travel, function (obj, key) {
//check if event already exists on this day
var result = vm.eventsForCalendar.filter(function (event) {
return formatDate(new Date(obj.Date)) === event.dateStart;
});
if (result.length == 0) {
var dateStart = new Date(obj.Date);
var event = {
"id": "t-" + obj.ID,
"title": obj.Country,
"description": "",
"url": "",
"country": obj.Country != null ? obj.Country.toLowerCase() : "",
"countryLong": "Tone is traveling in " + $filter('countryLong')(obj.Country),
"class": "event-Travel",
"eventTypeId": 7,
"allDay": true,
"dateStart": formatDate(dateStart),
"start": Date.parse(dateStart),
"end": new Date(obj.Date).setHours(24)
}
vm.eventsForCalendar.push(event);
}
});
}
function loadEventsCompleted(result) {
vm.events = result.data;
loadEventsForCalendar();
loadWorkshops();
}
function loadWorkshopsCompleted(result) {
vm.workshops = result.data;
loadWorkshopsForCalendar();
loadTravel();
}
function loadAvailabilityCompleted(result) {
vm.availability = result.data;
}
function loadTravelCompleted(result) {
vm.travel = result.data;
var tableParams = { page: 1, count: 10, sorting: {} }
vm.travelTable = new NgTableParams($scope.tableParams, { counts: [], total: vm.travel.length, dataset: vm.travel });
loadTravelForCalendar();
loadCalendar();
}
function loadAvailabilityForCalendar() {
$(".cal-cell1, .cal-month-day").off();
$(".cal-cell1").click(function () {
selectUnselectDay(this);
});
$('.cal-day-inmonth').each(function (index, item) {
var date = new Date(($(item).find('span').attr('data-cal-date')));
date.setDate(date.getDate() + 1);
date = formatDate(date);
var result = vm.availability.filter(function (obj) {
return formatDate(new Date(obj.Date)) === date;
});
if (result.length > 0) {
$(item).addClass('available');
}
else {
$(item).addClass('unavailable');
}
});
$('.add').remove();
}
function unloadAvailabilityForCalendar() {
vm.formData.isAvailability = false;
$('#calendar').html("");
loadCalendar();
}
function selectUnselectDay(e) {
if ($(e).find('.cal-day-inmonth').hasClass('unavailable')) $(e).find('.cal-day-inmonth').removeClass('unavailable').addClass('available');
else $(e).find('.cal-day-inmonth').removeClass('available').addClass('unavailable');
}
function selectUnselectMonth() {
if (vm.monthSelect == 0) {
$('.cal-day-inmonth').each(function (index, item) {
$(this).removeClass('available').addClass('unavailable');
});
}
else {
$('.cal-day-inmonth').each(function (index, item) {
$(this).removeClass('unavailable').addClass('available');
});
}
}
function loadCalendar() {
var options = {
events_source: vm.eventsForCalendar,
view: 'month',
tmpl_path: '../../Content/tmpls/admin/',
tmpl_cache: false,
day: 'now',
modal: false,
display_week_numbers: false,
weekbox: false,
format12: true,
onAfterEventsLoad: function (events) {
//console.info(events);
},
onAfterViewLoad: function (view) {
if (view == 'month') $('.availabilityMenu').show();
else $('.availabilityMenu').hide();
$('#hiddenView').val(view);
$('.calendar h3').text(this.getTitle());
$('.btn-group button').removeClass('active');
$('button[data-calendar-view="' + view + '"]').addClass('active');
},
classes: {
months: {
general: 'label'
}
}
};
var calendar = $('#calendar').calendar(options);
$('.btn-group button[data-calendar-nav]').each(function () {
var $this = $(this);
$this.click(function () {
calendar.navigate($this.data('calendar-nav'));
});
});
$('.btn-group button[data-calendar-view]').each(function () {
var $this = $(this);
$this.click(function () {
calendar.view($this.data('calendar-view'));
});
});
$('.events-list a').removeAttr('data-original-title');
vm.isLoading = false;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function updateFailed(response) {
notificationService.displayError(response.data.Message);
}
function deleteSucceeded(response) {
notificationService.displaySuccess('Successfully deleted');
loadEvents();
}
function formatTime(date) {
var hours = date.getHours();
var minutes = date.getMinutes();
var ampm = hours >= 12 ? 'pm' : 'am';
hours = hours % 12;
hours = hours ? hours : 12; // the hour '0' should be '12'
minutes = minutes < 10 ? '0' + minutes : minutes;
var strTime = hours + ':' + minutes + ' ' + ampm;
return strTime;
}
function formatDate(date) {
var strDate = (date.getMonth() + 1) + '/' + date.getDate() + '/' + date.getFullYear()
return strDate;
}
function formatLocation(location) {
var objLocation = {
city: '',
state: '',
country: ''
}
location = location.toLowerCase();
var split = location.split(',');
if (split.length == 3) {
objLocation.city = split[0];
objLocation.state = split[1].replace(/[\. ,:-]+/g, "");
objLocation.country = split[2].replace(/[\. ,:-]+/g, "");
}
else if (split.length == 2) {
objLocation.city = split[0];
objLocation.country = split[1].replace(/[\. ,:-]+/g, "");
}
else if (split.length == 1) {
objLocation.country = split[0].replace(/[\. ,:-]+/g, "");
}
return objLocation;
}
loadEvents();
loadAvailability();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('addCustomerCtrl', addCustomerCtrl);
addCustomerCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', 'apiService', 'NgTableParams', 'notificationService'];
function addCustomerCtrl($scope, $rootScope, $routeParams, $location, $modal, apiService, NgTableParams, notificationService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-add-customer';
var vm = this;
vm.customer = {
StatusId: 1,
TelegramStatusId: 4,
ConsultingTimeLeft: 0,
ReceiveEmails: true,
IndicatorAccess: false,
TradingViewAccess: false,
IsLegacy: false,
DateText: null,
LastUpdated: new Date(),
CreatedDate: new Date()
};
vm.create = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
create();
};
function create() {
apiService.post('/api/customers/add', vm.customer,
createSucceeded,
createFailed);
}
function createSucceeded() {
notificationService.displaySuccess('Successfully added customer');
$location.path('/admin/customers');
}
function createFailed (response) {
notificationService.displayError(response.data.Message);
}
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('editCustomerCtrl', editCustomerCtrl);
editCustomerCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$filter', '$modal', 'apiService', 'NgTableParams', 'notificationService'];
function editCustomerCtrl($scope, $rootScope, $routeParams, $location, $filter, $modal, apiService, NgTableParams, notificationService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-edit-customer';
var vm = this;
vm.isLoading = true;
vm.isLoadingTransactions = false;
vm.customer = {};
vm.orders = [];
vm.ordersTable = null;
vm.totalRecords = 0;
vm.transactions = [];
vm.seminars = [];
vm.seminarId = "0";
vm.formData = {
action: '',
transactionId: '',
discountAmount: '',
transactionId2: '',
paymentAddress: ''
};
vm.closePage = function () {
var prevPage = window.location.href;
window.history.go(-1);
setTimeout(function () {
if (window.location.href == prevPage) {
window.close();
}
}, 500);
};
vm.enableTelegram = function () {
vm.customer.TelegramStatusId = 1;
updateTelegram();
}
vm.disableTelegram = function () {
vm.customer.TelegramStatusId = 2;
updateTelegram();
}
vm.emailTelegramInfo = function () {
updateTelegram();
}
vm.edit = function (ID, top) {
//var full = location.protocol + '//' + location.hostname + (location.port ? ':' + location.port : '');
scrollToDiv('#' + ID, top);
}
vm.editSeminar = function (order) {
var fullPath = '/admin/workshops/edit/' + order.SeminarID;
window.open(fullPath, '_blank');
};
vm.editProduct = function (order) {
var fullPath = 'admin/products/edit/' + order.ProductID;
window.open(fullPath, '_blank');
};
vm.editConference = function (order) {
var fullPath = '/admin/conferences/edit/' + order.ConferenceProductID;
window.open(fullPath, '_blank');
};
vm.editSubscription = function (order) {
var fullPath = '/admin/subscriptions/edit/' + order.SubscriptionProductID;
window.open(fullPath, '_blank');
};
vm.editEvent = function (order) {
var fullPath = '/admin/events/edit/' + order.EventID;
window.open(fullPath, '_blank');
};
vm.addAccessNote = function (type) {
var notes = vm.customer.Notes != null ? vm.customer.Notes + '\n' : '';
if (type == 'Emails') {
notes += 'Updated Emails to ' + vm.customer.ReceiveEmails.toString() + ' on ' + new Date().toLocaleDateString("en-US");
}
else if (type == 'Indicator') {
notes += 'Updated Indicator Access to ' + vm.customer.IndicatorAccess.toString() + ' on ' + new Date().toLocaleDateString("en-US");
}
else if (type == 'TradingView') {
notes += 'Updated TradingView Access to ' + vm.customer.TradingViewAccess.toString() + ' on ' + new Date().toLocaleDateString("en-US");
}
vm.customer.Notes = notes;
}
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
update();
};
vm.askDelete = function (item) {
var modalHtml = 'This will also remove all of this customers orders. Are you sure?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
remove();
});
};
vm.askDeleteOrder = function (item) {
var modalHtml = 'Are you sure you want to delete this order?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
removeOrder(item);
});
};
vm.resendFinalConfirmEmail = function (order) {
resendFinalConfirmEmail(order);
};
vm.renewSubscription = function () {
renewSubscription();
};
vm.setConfirmed = function (orderID) {
setConfirmed(orderID);
};
vm.setCanceled = function (isCanceled, orderID) {
setCanceled(isCanceled, orderID);
};
vm.setPaidAndConfirmed = function (sForm, order) {
setPaidAndConfirmed(order);
};
vm.resendRegistrationEmail = function (order) {
resendRegistrationEmail(order);
};
vm.sendConfirmEmail = function (order) {
sendConfirmEmail(order);
};
vm.resendConfirmEmail = function (order) {
resendConfirmEmail(order);
};
vm.updateOrderCurrency = function (currencyType, orderID) {
updateOrderCurrency(currencyType, orderID);
};
vm.updateOrderValidity = function (isValid, orderID) {
updateOrderValidity(isValid, orderID);
};
vm.updateOrderSeminar = function (order) {
updateOrderSeminar(order);
};
vm.emailSeminarStreamURL = function (order) {
emailSeminarStreamURL(order);
};
vm.emailSeminarPreStreamURL = function (order) {
emailSeminarPreStreamURL(order);
};
vm.completePayment = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
completePayment();
};
vm.addDiscount = function (sForm2, order) {
if (sForm2.$invalid) {
angular.forEach(sForm2.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
addDiscount(order);
};
vm.removeDiscount = function (orderID) {
removeDiscount(orderID);
};
vm.updatePaymentAddress = function (sForm3, order) {
if (sForm3.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
updatePaymentAddress(order);
};
function emailSeminarPreStreamURL(order) {
apiService.put('/api/orders/email/seminarprestreamurl', order,
emailSeminarPreStreamURLSucceeded,
updateFailed);
}
function emailSeminarPreStreamURLSucceeded(response) {
notificationService.displaySuccess('Successfully sent meeting link to customer');
}
function emailSeminarStreamURL(order) {
apiService.put('/api/orders/email/seminarstreamurl', order,
emailSeminarStreamURLSucceeded,
updateFailed);
}
function emailSeminarStreamURLSucceeded(response) {
notificationService.displaySuccess('Successfully sent Youtube link to customer');
}
function sendConfirmEmail(order) {
apiService.put('/api/orders/email/seminarconfirmed', order,
emailSucceeded,
updateFailed);
}
function resendRegistrationEmail(order) {
apiService.put('/api/orders/email/registration', order,
emailSucceeded,
updateFailed);
}
function resendConfirmEmail(order) {
apiService.put('/api/orders/email/confirm', order,
emailSucceeded,
updateFailed);
}
function resendFinalConfirmEmail(order) {
apiService.put('/api/orders/email/finalconfirm', order,
emailSucceeded,
updateFailed);
}
function emailSucceeded(response) {
notificationService.displaySuccess('Successfully re-sent email');
}
function loadData() {
var url = '/api/orders/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
//function loadSeminars() {
// var url = '/api/seminars/location/' + vm.orderData.Seminar.Location;
// apiService.get(url, null,
// loadSeminarsCompleted,
// loadFailed
// );
//}
//function loadSeminarsCompleted(result) {
// vm.seminars = result.data;
// vm.seminars.push({ ID: "0", LocationAndDate: 'Workshops' });
// vm.isSeminarsLoaded = true;
//}
function remove(order) {
var url = '/api/orders/delete';
apiService.post(url, order,
deleteSucceeded,
updateFailed
);
}
function updateOrderCurrency(currencyType, orderID) {
var orderCurrencyType = {
OrderID: orderID,
CurrencyTypeID: currencyType
}
apiService.put('/api/orders/updatecurrency', orderCurrencyType,
updateOrderSucceeded,
updateFailed);
}
function updateOrderSeminar(isValid, orderID) {
var order = {
OrderID: orderID,
SeminarID: vm.seminarId
}
apiService.put('/api/orders/updateseminar', order,
updateOrderSucceeded,
updateFailed);
}
function updateOrderValidity(isValid, orderID) {
var order = {
OrderID: orderID,
IsValid: isValid
}
apiService.put('/api/orders/updatevalidity', order,
updateOrderSucceeded,
updateFailed);
}
function setConfirmed(orderID) {
var orderConfirm = {
OrderID: orderID,
StatusId: 3
}
apiService.put('/api/orders/confirm', orderConfirm,
confirmSucceeded,
updateFailed);
}
function setCanceled(isCanceled, orderID) {
var order = {
OrderID: orderID,
IsValid: isCanceled
}
apiService.put('/api/orders/cancel', order,
updateOrderSucceeded,
updateFailed);
}
function setPaidAndConfirmed(order) {
var payment = {
CustomerId: order.CustomerID,
InvoiceId: order.InvoiceID,
OrderId: order.ID,
TransactionId: vm.formData.transactionId
}
var url = '/api/orders/payandconfirm/';
apiService.put(url, payment,
setPaidAndConfirmedComplete,
loadFailed);
}
function setPaidAndConfirmedComplete(result) {
notificationService.displaySuccess('Successfully paid and confirmed order');
//$scope.sForm.$setPristine();
vm.isLoading = true;
loadOrders();
}
function addDiscount(order) {
var payment = {
OrderID: order.ID,
DiscountAmount: parseFloat(vm.formData.discountAmount) / 100.0
}
var url = '/api/orders/applydiscount/';
apiService.put(url, payment,
addDiscountComplete,
loadFailed);
}
function addDiscountComplete(result) {
notificationService.displaySuccess('Successfully added discount');
//$scope.sForm2.$setPristine();
vm.isLoading = true;
loadOrders();
}
function removeDiscount(orderID) {
var payment = {
OrderID: orderID,
DiscountAmount: 0
}
var url = '/api/orders/removediscount/';
apiService.put(url, payment,
removeDiscountComplete,
loadFailed);
}
function removeDiscountComplete(result) {
notificationService.displaySuccess('Successfully removed discount');
//$scope.sForm2.$setPristine();
vm.isLoading = true;
loadOrders();
}
function updatePaymentAddress(order) {
var orderUpdatePaymentAddress = {
Action: vm.formData.action,
OrderID: order.ID,
PaymentAddress: vm.formData.paymentAddress,
TransactionID: vm.formData.transactionId2
}
apiService.put('/api/orders/updatepaymentaddress', orderUpdatePaymentAddress,
updateSucceeded,
updateFailed);
}
function loadData() {
var url = '/api/customers/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function remove() {
var url = '/api/customers/delete';
apiService.post(url, vm.customer,
deleteSucceeded,
updateFailed
);
}
function removeOrder(order) {
console.log(order);
var url = '/api/orders/delete';
apiService.post(url, order,
deleteSucceededOrder,
updateFailed
);
}
function update() {
apiService.put('/api/customers/update', vm.customer,
updateSucceeded,
updateFailed);
}
function updateTelegram() {
apiService.put('/api/customers/update/telegram', vm.customer,
updateTelegramSucceeded,
updateFailed);
}
function loadCompleted(result) {
if (typeof result.data != "undefined") {
scrollToTop();
vm.customer = result.data;
console.info(vm.customer);
loadOrders();
}
else {
$location.path('/admin/customers');
}
}
function loadOrders() {
apiService.get('/api/orders/customer/' + vm.customer.ID, null,
loadOrdersCompleted,
loadFailed);
}
function loadOrdersCompleted(result) {
vm.orders = result.data;
vm.totalRecords = vm.orders.length;
var tableParams = { page: 1, count: 10, sorting: {} }
vm.ordersTable = new NgTableParams($scope.tableParams, { counts: [], total: vm.orders.length, dataset: vm.orders });
vm.orderDetailsTable = new NgTableParams($scope.tableParams, { counts: [], total: vm.orders.length, dataset: vm.orders });
vm.isLoading = false;
var hash = $location.hash();
if (hash != '') {
vm.edit('Orders', 80);
}
vm.isLoading = false;
}
function renewSubscription() {
apiService.put('/api/orders/renewsubscription', vm.customer,
renewSubscriptionSucceeded,
updateFailed);
}
//function resendFinalConfirmEmail() {
// apiService.put('/api/orders/email/finalconfirm/legacy', vm.customer,
// emailSucceeded,
// updateFailed);
//}
function emailSucceeded(response) {
notificationService.displaySuccess('Successfully sent email');
}
function renewSubscriptionSucceeded(response) {
notificationService.displaySuccess('Successfully created order and sent customer registration email');
loadOrders();
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully updated customer');
$scope.sForm.$setPristine();
}
function updateOrderSucceeded(response) {
notificationService.displaySuccess('Successfully updated order');
vm.isLoading = true;
loadOrders();
}
function confirmSucceeded(response) {
notificationService.displaySuccess('Successfully confirmed order');
$scope.sForm.$setPristine();
vm.isLoading = true;
loadOrders();
}
function updateTelegramSucceeded(response) {
notificationService.displaySuccess('Successfully updated telegram information');
$scope.sForm.$setPristine();
}
function deleteSucceeded(response) {
notificationService.displaySuccess('Successfully deleted customer');
$location.path('/admin/customers');
}
function deleteSucceededOrder(response) {
notificationService.displaySuccess('Successfully deleted order');
vm.isLoading = true;
loadOrders();
}
function updateFailed(response) {
notificationService.displayError(response.data.Message);
}
loadData();
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('customersCtrl', customersCtrl);
customersCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', '$q', 'apiService', 'customersService', 'notificationService', 'NgTableParams'];
function customersCtrl($scope, $rootScope, $filter, $location, $q, apiService, customersService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-customers';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.firstRun = true;
vm.customersTable = null;
vm.customers = [];
vm.filter = "";
vm.consultingTimeLeft = "";
vm.page = 0;
vm.pageSize = 100;
vm.pagesCount = 0;
vm.totalCount = 0;
vm.edit = function (customer) {
var fullPath = window.location.href + '/edit/' + customer.ID;
window.open(fullPath, '_blank');
//$location.path('/admin/customers/edit/' + customer.ID);
}
vm.pageChanged = function () {
search(vm.page);
};
vm.changePageSize = function () {
vm.page = 0;
search(0, true);
};
function search(page, reloadTable) {
if (reloadTable == true) {
vm.customersTable.reload();
}
else {
vm.customersTable.page(page);
}
}
vm.tableParams = { page: vm.page, count: vm.pageSize, sorting: {} }
vm.customersTable = new NgTableParams(vm.tableParams, {
counts: [], total: vm.totalCount,
getData: function (params) {
var order = params.orderBy().toString();
var orderBy = order.charAt(1).toUpperCase().length > 0 ? order.charAt(1).toUpperCase() + order.slice(2) : "";
var orderByDirection = order.charAt(0) == "+" ? "asc" : "desc";
var config = {
params: {
page: vm.page == 0 ? vm.page : vm.page - 1,
pageSize: vm.pageSize,
orderBy: orderBy,
orderByDirection: orderByDirection,
filter: vm.filter,
consultingTimeLeft: vm.consultingTimeLeft
}
};
return customersService.getCustomers(config).then(function (result) {
vm.customers = result.Items;
vm.pagesCount = result.TotalPages;
vm.totalCount = result.TotalCount;
return vm.customers;
});
}
});
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
function watch() {
$scope.$watch('[vm.filter, vm.consultingTimeLeft]', function (val) {
if (!vm.firstRun) {
if (vm.filter != '' && vm.filter.length > 2) {
search(0, true);
}
else if (vm.filter == '') {
search(0, true);
}
else {
//do nothing
}
}
vm.firstRun = false;
});
}
watch();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('telegramAdminCtrl', telegramAdminCtrl);
telegramAdminCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', 'apiService', 'notificationService', 'NgTableParams'];
function telegramAdminCtrl($scope, $rootScope, $filter, $location, apiService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-telegram';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.customersTable = null;
vm.customers = [];
vm.filter = "";
vm.telegramStatusId = "3";
vm.page = 0;
vm.pageSize = 10;
vm.pagesCount = 0;
vm.totalCount = 0;
vm.edit = function (customer) {
$location.path('/admin/customers/edit/' + customer.ID);
}
vm.pageChanged = function () {
search(vm.page - 1);
};
function search(page) {
page = page || 0;
var config = {
params: {
page: page,
pageSize: vm.pageSize,
filter: vm.filter,
telegramStatusId: vm.telegramStatusId,
}
};
apiService.get('/api/customers/', config,
loadCompleted,
loadFailed);
}
function loadCompleted(result) {
vm.customers = result.data.Items;
vm.pagesCount = result.data.TotalPages;
vm.totalCount = result.data.TotalCount;
var tableParams = { page: 1, count: vm.pageSize, sorting: {name: 'asc'}}
vm.customersTable = new NgTableParams(tableParams, { counts: [], total: vm.totalCount, dataset: vm.customers });
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
function watch() {
$scope.$watch('[vm.filter, vm.telegramStatusId]', function (val) {
if (val != '' && val != undefined && val.length > 2) {
search();
} else {
search(0);
}
});
}
watch();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('addDiscountCtrl', addDiscountCtrl);
addDiscountCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', 'apiService', 'NgTableParams', 'notificationService'];
function addDiscountCtrl($scope, $rootScope, $routeParams, $location, $modal, apiService, NgTableParams, notificationService) {
$scope.pageClass = 'page-admin-add-discount';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.seminars = [];
vm.products = [];
vm.conferences = [];
vm.subscriptions = [];
vm.discount = {
DiscountAmount: 0,
StatusId: 1,
DiscountTypeID: 4,
OrderTypeID: 3,
ItemID: 0,
CreatedDate: new Date(),
LastUpdated: new Date()
};
vm.discountStatus = [{ name: 'Enabled', id: 1 }, { name: 'Disabled', id: 2 }];
vm.orderType = [{ name: 'Conference', id: 3 }];
vm.discountType = [{ name: 'Dynamic', id: 4 }, { name: 'General', id: 2 }, { name: 'Restricted', id: 3 }];
vm.create = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
if (vm.discount.DiscountAmount == 0) {
vm.discount.DiscountAmount = 1;
}
else {
vm.discount.DiscountAmount = parseFloat(vm.discount.DiscountAmount) / 100.0;
}
apiService.post('/api/discounts/add', vm.discount,
createSucceded,
createFailed);
};
function createSucceded(response) {
notificationService.displaySuccess('Successfully added discount');
vm.discount = response.data;
sessionStorage.removeItem('/api/discounts/count/1');
$location.path('/admin/discounts');
}
function createFailed(response) {
notificationService.displayError(response.data.Message);
}
function loadSeminars() {
var url = '/api/seminars/all';
apiService.get(url, null,
loadSeminarsCompleted,
loadFailed
);
}
function loadSeminarsCompleted(result) {
vm.seminars = result.data;
vm.seminars.push({ ID: 0, LocationAndId: 'All Workshops' });
}
function loadProducts() {
var url = '/api/products/all';
apiService.get(url, null,
loadProductsCompleted,
loadFailed
);
}
function loadProductsCompleted(result) {
vm.products = result.data;
vm.products.push({ ID: 0, Title: 'All Products' });
}
function loadConferences() {
var url = '/api/conferences/all';
apiService.get(url, null,
loadConferencesCompleted,
loadFailed
);
}
function loadConferencesCompleted(result) {
vm.isLoading = false;
vm.conferences = result.data;
vm.conferences.push({ ID: 0, Title: 'All Conferences' });
}
function loadSubscriptions() {
var url = '/api/subscriptions/all';
apiService.get(url, null,
loadSubscriptionsCompleted,
loadFailed
);
}
function loadSubscriptionsCompleted(result) {
vm.isLoading = false;
vm.subscriptions = result.data;
vm.subscriptions.push({ ID: 0, Title: 'All Subscriptions' });
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
loadSeminars();
loadProducts();
loadConferences();
loadSubscriptions();
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('editDiscountCtrl', editDiscountCtrl);
editDiscountCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', 'apiService', 'NgTableParams', 'notificationService'];
function editDiscountCtrl($scope, $rootScope, $routeParams, $location, $modal, apiService, NgTableParams, notificationService) {
$scope.pageClass = 'page-admin-edit-discount';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.seminars = [];
vm.products = [];
vm.conferences = [];
vm.subscriptions = [];
vm.isLoading = true;
vm.discount = {};
vm.discountStatus = [{ name: 'Enabled', id: 1 }, { name: 'Disabled', id: 2 }]
vm.discountType = [{ name: 'Dynamic', id: 4 }, { name: 'General', id: 2 }, { name: 'Restricted', id: 3 }];
vm.DiscountAmountPercent = "";
vm.closePage = function () {
var prevPage = window.location.href;
window.history.go(-1);
setTimeout(function () {
if (window.location.href == prevPage) {
window.close();
}
}, 500);
};
vm.emailCoupon = function () {
email();
};
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
update();
};
vm.askDelete = function (item) {
var modalHtml = 'Are you sure you want to delete this?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
remove();
});
};
function email() {
apiService.put('/api/discounts/email', vm.discount,
emailSucceeded,
updateFailed);
}
function loadData() {
var url = '/api/discounts/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function loadOrders() {
apiService.get('/api/orders/discount/' + vm.discount.ID, null,
loadOrdersCompleted,
loadFailed);
}
function update() {
vm.discount.DiscountAmount = parseFloat(vm.DiscountAmountPercent) / 100.0;
apiService.put('/api/discounts/update', vm.discount,
updateSucceeded,
updateFailed);
}
function remove() {
var url = '/api/discounts/delete';
apiService.post(url, vm.discount,
deleteSucceeded,
updateFailed
);
}
function loadCompleted(result) {
vm.discount = result.data;
vm.DiscountAmountPercent = vm.discount.DiscountAmount * 100;
if (vm.discount.OrderTypeID == 1) {
loadSeminars();
}
else if (vm.discount.OrderTypeID == 2) {
loadProducts();
}
else if (vm.discount.OrderTypeID == 3) {
loadConferences();
}
else if (vm.discount.OrderTypeID == 6) {
loadSubscriptions();
}
//load orders using discount code if any
loadOrders();
}
function loadOrdersCompleted(result) {
vm.orders = result.data;
vm.totalRecords = vm.orders.length;
var tableParams = { page: 1, count: vm.orders.length, sorting: {} }
vm.ordersTable = new NgTableParams(tableParams, { counts: [], total: vm.orders.length, dataset: vm.orders });
vm.isLoading = false;
}
function loadSeminars() {
var url = '/api/seminars/all';
apiService.get(url, null,
loadSeminarsCompleted,
loadFailed
);
}
function loadSeminarsCompleted(result) {
vm.isLoading = false;
vm.seminars = result.data;
vm.seminars.push({ ID: null, LocationAndId: 'All Workshops' });
}
function loadProducts() {
var url = '/api/products/all';
apiService.get(url, null,
loadProductsCompleted,
loadFailed
);
}
function loadProductsCompleted(result) {
vm.isLoading = false;
vm.products = result.data;
vm.products.push({ ID: null, Title: 'All Products' });
}
function loadConferences() {
var url = '/api/conferences/all';
apiService.get(url, null,
loadConferencesCompleted,
loadFailed
);
}
function loadConferencesCompleted(result) {
//vm.isLoading = false;
vm.conferences = result.data;
vm.conferences.push({ ID: null, Title: 'All Conferences' });
}
function loadSubscriptions() {
var url = '/api/subscriptions/all';
apiService.get(url, null,
loadSubscriptionsCompleted,
loadFailed
);
}
function loadSubscriptionsCompleted(result) {
vm.isLoading = false;
vm.subscriptions = result.data;
vm.subscriptions.push({ ID: 0, Title: 'All Subscriptions' });
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully updated discount');
$scope.sForm.$setPristine();
sessionStorage.removeItem('/api/discounts/count/' + vm.discount.OrderTypeID);
vm.isLoading = true;
loadData();
}
vm.editCustomer = function (order) {
var full = location.protocol + '//' + location.hostname + (location.port ? ':' + location.port : '');
var url = full + '/admin/customers/edit/' + order.CustomerID;
window.open(url, '_blank');
};
function emailSucceeded(response) {
notificationService.displaySuccess('Successfully sent email');
}
function deleteSucceeded(response) {
notificationService.displaySuccess('Successfully deleted discount');
$location.path('/admin/discounts');
}
function updateFailed (response) {
notificationService.displayError(response.data.Message);
}
loadData();
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('discountsCtrl', discountsCtrl);
discountsCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', 'apiService', 'notificationService', 'NgTableParams'];
function discountsCtrl($scope, $rootScope, $filter, $location, apiService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-discounts';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.discountsTable = null;
vm.discounts = [];
vm.isLoading = true;
vm.filter = "";
vm.statusId = "";
vm.typeId = "";
vm.hasCoupon = null;
vm.page = 0;
vm.pageSize = 100;
vm.pagesCount = 0;
vm.totalCount = 0;
vm.edit = function (discount) {
var fullPath = window.location.href + '/edit/' + discount.ID;
window.open(fullPath, '_blank');
//$location.path('/admin/discounts/edit/' + discount.ID);
}
vm.pageChanged = function () {
search(vm.page - 1);
};
function search(page) {
page = page || 0;
var config = {
params: {
page: page,
pageSize: vm.pageSize,
filter: vm.filter,
statusId: vm.statusId,
typeId: vm.typeId,
hasCoupon: vm.hasCoupon
}
};
apiService.get('/api/discounts/', config,
loadCompleted,
loadFailed);
}
function loadCompleted(result) {
vm.discounts = result.data.Items;
vm.pagesCount = result.data.TotalPages;
vm.totalCount = result.data.TotalCount;
var tableParams = { page: 1, count: vm.pageSize, sorting: {} }
vm.discountsTable = new NgTableParams(tableParams, { counts: [], total: vm.totalCount, dataset: vm.discounts });
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function watch() {
$scope.$watch('[vm.filter, vm.statusId, vm.typeId, vm.hasCoupon]', function (val) {
if (val != '' && val != undefined && val.length > 2) {
search();
} else {
search(0);
}
});
}
watch();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('addBlogCtrl', addBlogCtrl);
addBlogCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$sce', '$location', '$filter', 'apiService', 'fileUploadService', 'NgTableParams', 'notificationService'];
function addBlogCtrl($scope, $rootScope, $routeParams, $sce, $location, $filter, apiService, fileUploadService, NgTableParams, notificationService) {
$scope.pageClass = 'page-admin-add-blog';
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.savePost = function () {
vm.createFromSaveButton();
};
$scope.re = /^[a-zA-Z0-9,\s]+$/;
var vm = this;
var blogImage = null;
vm.isLoading = true;
vm.newRandom = Math.random();
vm.blogStatus = [{ name: 'Enabled', id: 1 }, { name: 'Disabled', id: 2 }, { name: 'Draft', id: 3 }]
vm.blog = {
TitleURL: '',
StatusId: 3,
IsFeatured: false,
CreatedDate: new Date(),
LastUpdated: new Date()
};
vm.trust = $sce.trustAsHtml;
vm.prepareFiles = function ($files) {
blogImage = $files;
};
function loadData() {
var url = '/api/blogs/template';
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function loadCompleted(result) {
var template = result.data;
vm.blog.Body = template.Body;
//loadSummerNote();
vm.isLoading = false;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
vm.create = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
vm.isLoading = true;
//vm.blog.TitleURL = trimTitle($filter('urlEncode')(vm.blog.Title)); //commented out until we come up with something better
vm.blog.TitleURL = $filter('urlEncode')(vm.blog.Title);
vm.blog.Tags = vm.blog.Tags.replace(/, /g, ',').replace(/ ,/g, ',');
apiService.post('/api/blogs/add', vm.blog,
createSucceded,
createFailed);
};
function trimTitle(title) {
var split = title.split('-');
var length = split.length >= 3 ? Math.round(split.length / 2) + 1 : 0;
for (var i = 0; i < length - 1; i++) {
split.pop();
}
var newTitle = split.join('-');
return newTitle;
}
vm.createFromSaveButton = function () {
if (typeof vm.blog.Title == 'undefined' || typeof vm.blog.Description == 'undefined') {
notificationService.displayError("Title and Description are Required fields.");
return;
}
vm.isLoading = true;
//vm.blog.Body = $('#summernote').summernote('code');
apiService.post('/api/blogs/add', vm.blog,
createSucceded,
createFailed);
};
function createSucceded(response) {
notificationService.displaySuccess('Successfully added blog');
vm.blog = response.data;
sessionStorage.removeItem('/api/blogs/public');
sessionStorage.removeItem('/api/blogs/public/featured');
if (blogImage) {
fileUploadService.uploadImage(blogImage, 'blog', vm.blog.ID, redirectToList);
}
else {
redirectToList();
}
}
function redirectToList() {
$location.path('/admin/blogs/edit/' + vm.blog.ID);
}
function createFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function loadSummerNote() {
$(document).ready(function () {
setTimeout(function () {
$("#loadingSummerNote").hide();
$('#summernote').summernote({
toolbar: [
['fullscreen', ['fullscreen']],
['save', ['saveButton']],
['header', ['style']],
['style', ['bold', 'underline', 'italic', 'strikethrough']],
['font', ['fontsize', 'color']],
['para', ['ul', 'ol', 'paragraph']],
//['table', ['table']],
['insert', ['imageButton', 'video', 'link']],
['misc', ['undo', 'redo']],
['help', ['codeview', 'help']],
],
buttons: {
imageButton: ImageButton,
saveButton: SaveBlogButtonAdd
}
});
$('.note-btn').removeAttr('data-original-title');
}, 1000);
});
}
loadData();
scrollToTop();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('editBlogCtrl', editBlogCtrl);
editBlogCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$sce', '$modal', '$location', '$timeout', '$window', '$filter', 'apiService', 'fileUploadService', 'NgTableParams', 'notificationService'];
function editBlogCtrl($scope, $rootScope, $routeParams, $sce, $modal, $location, $timeout, $window, $filter, apiService, fileUploadService, NgTableParams, notificationService) {
$scope.pageClass = 'page-admin-edit-blog';
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.savePost = function () {
update();
};
$scope.re = /^[a-zA-Z0-9,\s]+$/;
var vm = this;
var timeout = null;
var blogImage = null;
vm.newRandom = Math.random();
vm.isLoading = true;
vm.blogStatus = [{ name: 'Enabled', id: 1 }, { name: 'Disabled', id: 2 }, { name: 'Draft', id: 3 }]
vm.initial = {};
vm.blog = {};
vm.trust = $sce.trustAsHtml;
vm.edit = function (blog) {
$location.path('/admin/blogs/edit/' + blog.ID);
}
vm.prepareFiles = function ($files) {
blogImage = $files;
};
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
if (blogImage) {
fileUploadService.uploadImage(blogImage, 'blog', vm.blog.ID, blogImageCompleted);
}
else {
update();
}
};
vm.askDelete = function (item) {
var modalHtml = 'Are you sure you want to delete this?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
remove();
});
};
function loadData() {
var url = '/api/blogs/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function loadCompleted(result) {
vm.blog = result.data;
vm.blog.IsFeatured = vm.blog.IsFeatured + '';
vm.blog.LastUpdated = new Date();
vm.initial.Body = vm.blog.Body;
loadSummerNote();
vm.isLoading = false;
loadTimer();
}
function blogImageCompleted() {
update();
}
function update() {
vm.blog.TitleURL = $filter('urlEncode')(vm.blog.Title);
vm.blog.Tags = vm.blog.Tags.replace(/, /g, ',').replace(/ ,/g, ',');
vm.blog.Body = $('#summernote').summernote('code');
vm.initial.Body = vm.blog.Body;
apiService.put('/api/blogs/update', vm.blog,
updateSucceeded,
updateFailed);
}
function remove() {
var url = '/api/blogs/delete';
apiService.post(url, vm.blog,
deleteSucceeded,
updateFailed
);
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully updated blog');
sessionStorage.removeItem('/api/blogs/public');
sessionStorage.removeItem('/api/blogs/public/featured');
$scope.sForm.$setPristine();
vm.blog.LastUpdated = new Date();
loadTimer();
}
function deleteSucceeded(response) {
notificationService.displaySuccess('Successfully deleted blog');
sessionStorage.removeItem('/api/blogs/public');
sessionStorage.removeItem('/api/blogs/public/featured');
$location.path('/admin/blogs');
}
function updateFailed (response) {
notificationService.displayError(response);
}
function loadSummerNote() {
$(document).ready(function () {
setTimeout(function () {
$("#loadingSummerNote").hide();
$('#summernote').summernote({
toolbar: [
['fullscreen', ['fullscreen']],
['save', ['saveButton']],
['header', ['style']],
['style', ['bold', 'underline', 'italic', 'strikethrough']],
['font', ['fontsize', 'color']],
['para', ['ul', 'ol', 'paragraph']],
//['table', ['table']],
['insert', ['imageButton', 'video', 'link']],
['misc', ['undo', 'redo']],
['help', ['codeview', 'help']],
],
buttons: {
imageButton: ImageButton,
saveButton: SaveBlogButtonEdit
}
});
$('.note-btn').removeAttr('data-original-title');
}, 1000);
});
}
function loadTimer() {
if (timeout) {
$timeout.cancel(timeout)
}
timeout = $timeout(update, (60000 * 15)); //15 minutes
//timeout = $timeout(update, (60000)); //15 minutes
}
loadData();
scrollToTop();
//destroy timer upon leaving page
$scope.$on("$destroy", function () {
$timeout.cancel(timeout)
});
//check for unsaved changes
$window.onbeforeunload = function (event) {
vm.blog.Body = $('#summernote').summernote('code');
if ($scope.sForm.$dirty || vm.initial.Body !== vm.blog.Body) {
return 'You have made changes, but you did not save them yet.\nLeaving the page will revert all changes.';
}
}
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('blogsCtrl', blogsCtrl);
blogsCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', 'apiService', 'notificationService', 'NgTableParams'];
function blogsCtrl($scope, $rootScope, $filter, $location, apiService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-blogs';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.blogsTable = null;
vm.blogs = [];
vm.isLoading = true;
vm.filter = "";
vm.statusId = "";
vm.fromDate = "";
vm.toDate = "";
vm.page = 0;
vm.pageSize = 10;
vm.pagesCount = 0;
vm.totalCount = 0;
vm.datepicker = {};
vm.datepicker2 = {};
vm.dateOptions = {
formatYear: 'yy',
startingDay: 1,
showWeeks: false
};
vm.openDatePicker = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker.opened = true;
};
vm.openDatePicker2 = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker2.opened = true;
};
vm.edit = function (blog) {
$location.path('/admin/blogs/edit/' + blog.ID);
}
vm.pageChanged = function () {
search(vm.page - 1);
};
vm.changePageSize = function () {
vm.page = 0;
search(0);
};
function search(page) {
page = page || 0;
var config = {
params: {
page: page,
pageSize: vm.pageSize,
filter: vm.filter,
statusId: vm.statusId,
fromDate: vm.fromDate,
toDate: vm.toDate
}
};
apiService.get('/api/blogs/', config,
loadCompleted,
loadFailed);
}
function loadCompleted(result) {
vm.blogs = result.data.Items;
vm.pagesCount = result.data.TotalPages;
vm.totalCount = result.data.TotalCount;
var tableParams = { page: 1, count: vm.pageSize, sorting: {} }
vm.blogsTable = new NgTableParams(tableParams, { counts: [], total: vm.totalCount, dataset: vm.blogs });
vm.isLoading = false;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function watch() {
$scope.$watch('[vm.filter, vm.statusId, vm.fromDate, vm.toDate]', function (val) {
if (val != '' && val != undefined && val.length > 2) {
search();
} else {
search(0);
}
});
}
watch();
scrollToTop();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('blogsFeaturedCtrl', blogsFeaturedCtrl);
blogsFeaturedCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', 'apiService', 'notificationService', 'NgTableParams'];
function blogsFeaturedCtrl($scope, $rootScope, $filter, $location, apiService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-blogs-featured';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.blogs = [];
vm.featuredBlogs = [];
vm.isLoading = true;
vm.featured = {}
vm.update = function () {
update();
};
vm.selectFirstBlog = function ($item, $model, $label) {
vm.featured.first = $item;
};
vm.selectSecondBlog = function ($item, $model, $label) {
vm.featured.second = $item;
};
vm.selectThirdBlog = function ($item, $model, $label) {
vm.featured.third = $item;
};
vm.selectFourthBlog = function ($item, $model, $label) {
vm.featured.fourth = $item;
};
function loadData() {
apiService.get('/api/blogs/all', null,
loadDataCompleted,
loadFailed
);
}
function loadDataCompleted(result) {
vm.blogs = result.data;
setFeaturedBlogs();
vm.loading = false;
}
function setFeaturedBlogs() {
vm.featuredBlogs = vm.blogs.filter(function (obj) {
return obj.IsFeatured === true;
});
vm.featured.first = vm.featuredBlogs[0];
vm.featured.second = vm.featuredBlogs[1];
vm.featured.third = vm.featuredBlogs[2];
vm.featured.fourth = vm.featuredBlogs[3];
}
function update() {
var data = {
First: vm.featured.first.ID,
Second: vm.featured.second.ID,
Third: vm.featured.third.ID,
Fourth: vm.featured.fourth.ID
};
apiService.put('/api/blogs/update/featured', data,
updateSucceeded,
updateFailed);
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully updated featured blogs');
sessionStorage.removeItem('/api/blogs/public');
sessionStorage.removeItem('/api/blogs/public/featured');
vm.isLoading = true;
loadData();
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function updateFailed(response) {
notificationService.displayError(response);
}
loadData();
scrollToTop();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('paypalSuccessCtrl', paypalSuccessCtrl);
paypalSuccessCtrl.$inject = ['$scope', '$rootScope', '$filter', '$sce', '$routeParams', 'apiService', 'notificationService'];
function paypalSuccessCtrl($scope, $rootScope, $filter, $sce, $routeParams, apiService, notificationService) {
$rootScope.$broadcast("updatePageLocation", "products");
$scope.pageClass = 'page-products';
var vm = this;
vm.isLoading = true;
vm.isError = false;
vm.isValidated = false;
vm.errorMessage = "";
vm.trust = $sce.trustAsHtml;
vm.pageContent = $scope.$parent.getPageContent("PaypalSuccess");
vm.trustSrc = function (src) {
return $sce.trustAsResourceUrl(src);
}
$scope.$on('pageContentLoaded', function (event, data) {
vm.pageContent = $scope.$parent.getPageContent("PaypalSuccess");
});
function paypalExecute() {
var paymentId = getUrlParameter("paymentId");
var PayerID = getUrlParameter("PayerID");
var token = getUrlParameter("token");
var url = '';
if (paymentId == undefined || PayerID == undefined) {
url = '/api/orders/paypal/' + token;
}
else {
url = '/api/orders/paypal/' + token + '/' + paymentId + '/' + PayerID;
}
apiService.get(url, null,
getOrderDataCompleted,
getOrderDataFailed
);
}
function getOrderDataCompleted(result) {
vm.isValidated = true;
vm.isLoading = false;
}
function getOrderDataFailed(response) {
vm.isLoading = false;
vm.isError = true;
vm.errorMessage = response.data.Message;
if (vm.errorMessage == null || vm.errorMessage == "") vm.errorMessage = "Something went wrong."
}
scrollToTop();
paypalExecute();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('paypalCancelCtrl', paypalCancelCtrl);
paypalCancelCtrl.$inject = ['$scope', '$rootScope', '$filter', '$sce', '$routeParams', 'apiService', 'notificationService'];
function paypalCancelCtrl($scope, $rootScope, $filter, $sce, $routeParams, apiService, notificationService) {
$rootScope.$broadcast("updatePageLocation", "products");
$scope.pageClass = 'page-products';
var vm = this;
vm.isLoading = true;
vm.isError = false;
vm.isValidated = false;
vm.errorMessage = "";
vm.trust = $sce.trustAsHtml;
vm.pageContent = $scope.$parent.getPageContent("PaypalCancel");
vm.trustSrc = function (src) {
return $sce.trustAsResourceUrl(src);
}
$scope.$on('pageContentLoaded', function (event, data) {
vm.pageContent = $scope.$parent.getPageContent("PaypalCancel");
});
function cancelOrder() {
var paymentId = getUrlParameter("paymentId");
var PayerID = getUrlParameter("PayerID");
var invoiceId = getUrlParameter("id");
var token = getUrlParameter("token");
var url = '/api/orders/paypalcancel/' + token + '/' + invoiceId;
apiService.get(url, null,
cancelOrderCompleted,
cancelOrderFailed
);
}
function cancelOrderCompleted(result) {
vm.isValidated = true;
vm.isLoading = false;
}
function cancelOrderFailed(response) {
vm.isLoading = false;
vm.isError = true;
vm.errorMessage = response.data.Message;
}
scrollToTop();
cancelOrder();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('adminHelpCtrl', adminHelpCtrl);
adminHelpCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', 'apiService', 'notificationService', 'NgTableParams'];
function adminHelpCtrl($scope, $rootScope, $filter, $location, apiService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-help';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
setTimeout(function () {
if (window.location.hash) {
$(".page-admin-help .tab-pane").removeClass("active");
$(window.location.hash).addClass('active');
$(".page-admin-help .nav-pills li").removeClass("active");
$(".page-admin-help .nav-pills a[href='" + window.location.hash + "']").parent("li").addClass("active");
}
else {
$(".page-admin-help .tab-pane:first").addClass('active');
$(".page-admin-help .nav-pills a:first").parent("li").addClass("active");
}
}, 250);
scrollToTop();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('batchAddPaymentAddressCtrl', batchAddPaymentAddressCtrl);
batchAddPaymentAddressCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', 'apiService', 'bitcoinService', 'NgTableParams', 'notificationService'];
function batchAddPaymentAddressCtrl($scope, $rootScope, $routeParams, $location, $modal, apiService, bitcoinService, NgTableParams, notificationService) {
$scope.pageClass = 'page-admin-batch-add-payment-address';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.paymentAddress = {
StatusId: 1,
CurrencyTypeID: 1,
PaymentAddressBatch: ''
};
vm.paymentAddressInput = '';
vm.foundAddresses = '';
vm.addressCount = 0;
vm.validCount = 0;
vm.invalidCount = 0;
vm.paymentAddressStatus = [{ name: 'Enabled', id: 1 }, { name: 'Disabled', id: 2 }]
vm.create = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
apiService.post('/api/paymentaddress/batchadd', vm.paymentAddress,
createSucceded,
createFailed);
};
vm.processAddresses = function () {
if (vm.paymentAddress.PaymentAddressBatch != undefined) {
vm.validCount = 0;
vm.invalidCount = 0;
var re = new RegExp("^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$");
var filtered = vm.paymentAddressInput.replace(/(\r\n|\n|\r)/gm, "").replace(/,\s*$/, "");
vm.paymentAddress.PaymentAddressBatch = filtered;
var arr = filtered.split(",");
for (var i = 0; i < arr.length; i++) {
if (arr[i].match(re)) {
vm.validCount += 1;
}
else {
vm.invalidCount += 1;
}
}
vm.addressCount = arr.length;
}
else {
vm.addressCount = 0;
vm.validCount = 0;
vm.invalidCount = 0;
}
};
function createSucceded(response) {
notificationService.displaySuccess('Successfully added payment address');
vm.paymentAddress = response.data;
$location.path('/admin/paymentaddress');
}
function createFailed(response) {
notificationService.displayError(response.data.Message);
}
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('addPaymentAddressCtrl', addPaymentAddressCtrl);
addPaymentAddressCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', 'apiService', 'bitcoinService', 'NgTableParams', 'notificationService'];
function addPaymentAddressCtrl($scope, $rootScope, $routeParams, $location, $modal, apiService, bitcoinService, NgTableParams, notificationService) {
$scope.pageClass = 'page-admin-add-payment-address';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.paymentAddress = {
StatusId: 1,
CurrencyTypeID: 1,
PubIndex: 0,
CreatedDate: new Date()
};
vm.paymentAddressStatus = [{ name: 'Enabled', id: 1 }, { name: 'Disabled', id: 2 }]
vm.create = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
apiService.post('/api/paymentaddress/add', vm.paymentAddress,
createSucceded,
createFailed);
};
vm.validatePaymentAddress = function () {
if (typeof vm.paymentAddress.Address != "undefined") {
$('#paymentAddress').addClass('input-loading');
bitcoinService.isAddressValid(
vm.paymentAddress.Address,
bitcoinServiceLoadCompleted,
bitcoinServiceFailed,
true
);
}
else return;
};
function bitcoinServiceLoadCompleted(result) {
$('#paymentAddress').removeClass('input-loading');
if (result.data.data.is_valid) {
setPaymentAddressValid();
}
else {
setPaymentAddressInvalid();
}
}
function bitcoinServiceFailed(response) {
$('#paymentAddress').removeClass('input-loading');
notificationService.displayError(response.data.Message);
}
function createSucceded(response) {
notificationService.displaySuccess('Successfully added payment address');
vm.paymentAddress = response.data;
$location.path('/admin/paymentaddress');
}
function createFailed(response) {
notificationService.displayError(response.data.Message);
}
function setPaymentAddressValid() {
$('#paymentAddressFormGroup').removeClass('has-error');
$('#paymentAddressFormGroup label.has-error').remove();
$scope.sForm.paymentAddress.$setValidity("valid", true);
}
function setPaymentAddressInvalid() {
$('#paymentAddressFormGroup').addClass('has-error');
$scope.sForm.paymentAddress.$setValidity("valid", false);
}
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('editPaymentAddressCtrl', editPaymentAddressCtrl);
editPaymentAddressCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', 'apiService', 'bitcoinService', 'NgTableParams', 'notificationService'];
function editPaymentAddressCtrl($scope, $rootScope, $routeParams, $location, $modal, apiService, bitcoinService, NgTableParams, notificationService) {
$scope.pageClass = 'page-admin-edit-payment-address';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.isLoading = true;
vm.paymentAddress = {};
vm.paymentAddressStatus = [{ name: 'Enabled', id: 1 }, { name: 'Disabled', id: 2 }, { name: 'Used', id: 3 }];
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
update();
};
vm.validatePaymentAddress = function () {
if (typeof vm.paymentAddress.Address != "undefined") {
$('#paymentAddress').addClass('input-loading');
bitcoinService.isAddressValid(
vm.paymentAddress.Address,
bitcoinServiceLoadCompleted,
bitcoinServiceFailed,
true
);
}
else return;
};
function bitcoinServiceLoadCompleted(result) {
$('#paymentAddress').removeClass('input-loading');
if (result.data.data.is_valid) {
setPaymentAddressValid();
}
else {
setPaymentAddressInvalid();
}
}
function bitcoinServiceFailed(response) {
$('#paymentAddress').removeClass('input-loading');
notificationService.displayError(response.data.Message);
}
vm.askDelete = function (item) {
var modalHtml = 'Are you sure you want to delete this?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
remove();
});
};
function loadData() {
var url = '/api/paymentaddress/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function update() {
apiService.put('/api/paymentaddress/update', vm.paymentAddress,
updateSucceeded,
updateFailed);
}
function remove() {
var url = '/api/paymentaddress/delete';
apiService.post(url, vm.paymentAddress,
deleteSucceeded,
updateFailed
);
}
function loadCompleted(result) {
vm.paymentAddress = result.data;
vm.isLoading = false;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully updated payment address');
$scope.sForm.$setPristine();
vm.isLoading = true;
loadData();
}
function deleteSucceeded(response) {
notificationService.displaySuccess('Successfully deleted payment address');
$location.path('/admin/paymentaddress');
}
function updateFailed (response) {
notificationService.displayError(response.data.Message);
}
function setPaymentAddressValid() {
$('#paymentAddressFormGroup').removeClass('has-error');
$('#paymentAddressFormGroup label.has-error').remove();
$scope.sForm.paymentAddress.$setValidity("valid", true);
}
function setPaymentAddressInvalid() {
$('#paymentAddressFormGroup').addClass('has-error');
$scope.sForm.paymentAddress.$setValidity("valid", false);
}
loadData();
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('paymentAddressesCtrl', paymentAddressesCtrl);
paymentAddressesCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', 'apiService', 'notificationService', 'NgTableParams'];
function paymentAddressesCtrl($scope, $rootScope, $filter, $location, apiService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-payment-addresses';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.paymentAddressesTable = null;
vm.paymentAddresses = [];
vm.pubKeys = [];
vm.pubKeysDropdown = [];
vm.isLoading = true;
vm.filter = "";
vm.statusId = "";
vm.pubKeyId = "0";
vm.hasCoupon = null;
vm.page = 0;
vm.pageSize = 10;
vm.pagesCount = 0;
vm.totalCount = 0;
vm.edit = function (paymentAddress) {
$location.path('/admin/paymentaddress/edit/' + paymentAddress.ID);
}
vm.editPubKey = function (pubKey) {
$location.path('/admin/pubkeys/edit/' + pubKey.ID);
}
vm.pageChanged = function () {
search(vm.page - 1);
};
vm.changePageSize = function () {
vm.page = 0;
search(0);
};
function search(page) {
page = page || 0;
var config = {
params: {
page: page,
pageSize: vm.pageSize,
filter: vm.filter,
statusId: vm.statusId,
pubKeyId: vm.pubKeyId
}
};
apiService.get('/api/paymentaddress/', config,
loadCompleted,
loadFailed);
}
function loadCompleted(result) {
vm.paymentAddresses = result.data.Items;
//manually add count index
if (vm.page == 1 || vm.page == 0) {
angular.forEach(vm.paymentAddresses, function (item, index) {
item.index = index + 1;
});
}
else {
angular.forEach(vm.paymentAddresses, function (item, index) {
item.index = (vm.page * vm.pageSize) - vm.pageSize + (index + 1);
});
}
vm.pagesCount = result.data.TotalPages;
vm.totalCount = result.data.TotalCount;
var tableParams = { page: 1, count: vm.pageSize, sorting: {} }
vm.paymentAddressesTable = new NgTableParams(tableParams, { counts: [], total: vm.totalCount, dataset: vm.paymentAddresses });
vm.isLoading = false;
}
function loadPubKeys() {
apiService.get('/api/pubkeys/all', null,
loadPubkeysCompleted,
loadFailed);
}
function loadPubkeysCompleted(result) {
vm.pubKeys = result.data;
vm.totalPubKeys = vm.pubKeys.length;
if (vm.totalPubKeys > 0) {
angular.forEach(vm.pubKeys, function (item) {
var newItem = item;
if (newItem.Address.length > 50) newItem.Address = newItem.Address.substr(0, 50) + "...";
vm.pubKeysDropdown.push(newItem);
});
}
vm.pubKeysDropdown.push({ ID: "0", Title: "Pub Keys" });
vm.pubKeysDropdown.push({ ID: "all", Title: "Any" });
vm.pubKeysDropdown.push({ ID: "none", Title: "None" });
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function watch() {
$scope.$watch('[vm.filter, vm.statusId, vm.pubKeyId]', function (val) {
if (val != '' && val != undefined && val.length > 2) {
search();
} else {
search(0);
}
});
}
watch();
loadPubKeys();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('pubKeysCtrl', pubKeysCtrl);
pubKeysCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', 'apiService', 'notificationService', 'NgTableParams'];
function pubKeysCtrl($scope, $rootScope, $filter, $location, apiService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-pubkeys';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.username = $scope.$parent.loggedUser.username;
vm.pubKeysTable = null;
vm.pubKeys = [];
vm.pubKeysDropdown = [];
vm.isLoading = true;
vm.filter = "";
vm.statusId = "";
vm.hasCoupon = null;
vm.page = 0;
vm.pageSize = 100;
vm.pagesCount = 0;
vm.totalCount = 0;
vm.edit = function (pubKey) {
$location.path('/admin/pubkeys/edit/' + pubKey.ID);
}
vm.pageChanged = function () {
search(vm.page - 1);
};
vm.changePageSize = function () {
vm.page = 0;
search(0);
};
function search(page) {
page = page || 0;
var config = {
params: {
page: page,
pageSize: vm.pageSize,
filter: vm.filter,
statusId: vm.statusId
}
};
apiService.get('/api/pubkeys/', config,
loadCompleted,
loadFailed);
}
function loadCompleted(result) {
vm.pubKeys = result.data.Items;
//manually add count index
if (vm.page == 1 || vm.page == 0) {
angular.forEach(vm.pubKeys, function (item, index) {
item.index = index + 1;
});
}
else {
angular.forEach(vm.pubKeys, function (item, index) {
item.index = (vm.page * vm.pageSize) - vm.pageSize + (index + 1);
});
}
vm.pagesCount = result.data.TotalPages;
vm.totalCount = result.data.TotalCount;
var tableParams = { page: 1, count: vm.pageSize, sorting: {} }
vm.pubKeysTable = new NgTableParams(tableParams, { counts: [], total: vm.totalCount, dataset: vm.pubKeys });
vm.isLoading = false;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function watch() {
$scope.$watch('[vm.filter, vm.statusId]', function (val) {
if (val != '' && val != undefined && val.length > 2) {
search();
} else {
search(0);
}
});
}
if (vm.username != 'shib' && vm.username != 'tonevays') {
$location.path('/admin');
}
watch();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('addPubKeyCtrl', addPubKeyCtrl);
addPubKeyCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', 'apiService', 'bitcoinService', 'NgTableParams', 'notificationService'];
function addPubKeyCtrl($scope, $rootScope, $routeParams, $location, $modal, apiService, bitcoinService, NgTableParams, notificationService) {
$scope.pageClass = 'page-admin-add-pubkey';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.seminars = [];
vm.products = [];
vm.conferences = [];
vm.subscriptions = [];
vm.seminarsLoaded = false;
vm.productsLoaded = false;
vm.conferencesLoaded = false;
vm.subscriptionsLoaded = false;
vm.username = $scope.$parent.loggedUser.username;
vm.pubKey = {
OrderTypeID: 1,
StatusId: 1,
Title: "",
Address: "",
LastIndex: 0,
ItemID: null,
CreatedDate: new Date()
};
vm.orderType = [{ name: 'Workshop', id: 1 }, { name: 'Product', id: 2 }, { name: 'Conference', id: 3 }, { name: 'Subscription', id: 6 }]
vm.paymentAddressStatus = [{ name: 'Enabled', id: 1 }, { name: 'Disabled', id: 2 }]
vm.create = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
apiService.post('/api/pubKeys/add', vm.pubKey,
createSucceded,
createFailed);
};
vm.loadItems = function () {
vm.pubKey.ItemID = null;
loadItems();
};
function loadItems() {
if (vm.pubKey.OrderTypeID == 1 && vm.seminarsLoaded == false) {
loadSeminars();
}
else if (vm.pubKey.OrderTypeID == 2 && vm.productsLoaded == false) {
loadProducts();
}
else if (vm.pubKey.OrderTypeID == 3 && vm.conferencesLoaded == false) {
loadConferences();
}
else if (vm.pubKey.OrderTypeID == 6 && vm.subscriptionsLoaded == false) {
loadSubscriptions();
}
}
function loadSeminars() {
var url = '/api/seminars/all';
apiService.get(url, null,
loadSeminarsCompleted,
loadFailed
);
}
function loadSeminarsCompleted(result) {
vm.isLoading = false;
vm.seminars = result.data;
vm.seminars.push({ ID: null, LocationAndId: 'All Workshops' });
vm.seminarsLoaded = true;
}
function loadProducts() {
var url = '/api/products/all';
apiService.get(url, null,
loadProductsCompleted,
loadFailed
);
}
function loadProductsCompleted(result) {
vm.isLoading = false;
vm.products = result.data;
vm.products.push({ ID: null, Title: 'All Products' });
vm.productsLoaded = true;
}
function loadConferences() {
var url = '/api/conferences/all';
apiService.get(url, null,
loadConferencesCompleted,
loadFailed
);
}
function loadConferencesCompleted(result) {
vm.isLoading = false;
vm.conferences = result.data;
vm.conferences.push({ ID: null, Title: 'All Conferences' });
vm.conferencesLoaded = true;
}
function loadSubscriptions() {
var url = '/api/subscriptions/all';
apiService.get(url, null,
loadSubscriptionsCompleted,
loadFailed
);
}
function loadSubscriptionsCompleted(result) {
vm.isLoading = false;
vm.subscriptions = result.data;
vm.subscriptions.push({ ID: null, Title: 'All Subscriptions' });
vm.subscriptionsLoaded = true;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function createSucceded(response) {
notificationService.displaySuccess('Successfully added pubKey');
vm.pubKey = response.data;
$location.path('/admin/pubkeys');
}
function createFailed(response) {
notificationService.displayError(response.data.Message);
}
if (vm.username != 'shib' && vm.username != 'tonevays') {
$location.path('/admin');
}
loadItems();
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('editPubKeyCtrl', editPubKeyCtrl);
editPubKeyCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', 'apiService', 'bitcoinService', 'NgTableParams', 'notificationService'];
function editPubKeyCtrl($scope, $rootScope, $routeParams, $location, $modal, apiService, bitcoinService, NgTableParams, notificationService) {
$scope.pageClass = 'page-admin-edit-pubkey';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.seminars = [];
vm.products = [];
vm.conferences = [];
vm.subscriptions = [];
vm.seminarsLoaded = false;
vm.productsLoaded = false;
vm.conferencesLoaded = false;
vm.subscriptionsLoaded = false;
vm.isLoading = true;
vm.pubKey = {};
vm.orderType = [{ name: 'Workshop', id: 1 }, { name: 'Product', id: 2 }, { name: 'Conference', id: 3 }, { name: 'Subscription', id: 6 }]
vm.paymentAddressStatus = [{ name: 'Enabled', id: 1 }, { name: 'Disabled', id: 2 }];
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
update();
};
vm.askDelete = function (item) {
var modalHtml = 'Are you sure you want to delete this?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
remove();
});
};
vm.loadItems = function () {
vm.pubKey.ItemID = null;
loadItems();
};
function loadData() {
var url = '/api/pubkeys/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function update() {
apiService.put('/api/pubkeys/update', vm.pubKey,
updateSucceeded,
updateFailed);
}
function remove() {
var url = '/api/pubkeys/delete';
apiService.post(url, vm.pubKey,
deleteSucceeded,
updateFailed
);
}
function loadCompleted(result) {
vm.pubKey = result.data;
vm.isLoading = false;
loadItems();
}
function loadItems() {
if (vm.pubKey.OrderTypeID == 1 && vm.seminarsLoaded == false) {
loadSeminars();
}
else if (vm.pubKey.OrderTypeID == 2 && vm.productsLoaded == false) {
loadProducts();
}
else if (vm.pubKey.OrderTypeID == 3 && vm.conferencesLoaded == false) {
loadConferences();
}
else if (vm.pubKey.OrderTypeID == 6 && vm.subscriptionsLoaded == false) {
loadSubscriptions();
}
}
function loadSeminars() {
var url = '/api/seminars/all';
apiService.get(url, null,
loadSeminarsCompleted,
loadFailed
);
}
function loadSeminarsCompleted(result) {
vm.isLoading = false;
vm.seminars = result.data;
vm.seminars.push({ ID: null, LocationAndId: 'All Workshops' });
vm.seminarsLoaded = true;
}
function loadProducts() {
var url = '/api/products/all';
apiService.get(url, null,
loadProductsCompleted,
loadFailed
);
}
function loadProductsCompleted(result) {
vm.isLoading = false;
vm.products = result.data;
vm.products.push({ ID: null, Title: 'All Products' });
vm.productsLoaded = true;
}
function loadConferences() {
var url = '/api/conferences/all';
apiService.get(url, null,
loadConferencesCompleted,
loadFailed
);
}
function loadConferencesCompleted(result) {
vm.isLoading = false;
vm.conferences = result.data;
vm.conferences.push({ ID: null, Title: 'All Conferences' });
vm.conferencesLoaded = true;
}
function loadSubscriptions() {
var url = '/api/subscriptions/all';
apiService.get(url, null,
loadSubscriptionsCompleted,
loadFailed
);
}
function loadSubscriptionsCompleted(result) {
vm.isLoading = false;
vm.subscriptions = result.data;
vm.subscriptions.push({ ID: null, Title: 'All Subscriptions' });
vm.subscriptionsLoaded = true;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully updated pub key');
$scope.sForm.$setPristine();
vm.isLoading = true;
loadData();
}
function deleteSucceeded(response) {
notificationService.displaySuccess('Successfully deleted pub key');
$location.path('/admin/pubkeys');
}
function updateFailed (response) {
notificationService.displayError(response.data.Message);
}
loadData();
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('addSeminarCtrl', addSeminarCtrl);
addSeminarCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$sce', '$filter', 'apiService', 'notificationService', 'bitcoinService', 'fileUploadService'];
function addSeminarCtrl($scope, $rootScope, $routeParams, $location, $sce, $filter, apiService, notificationService, bitcoinService, fileUploadService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-add-seminar';
var vm = this;
var seminarImage = null;
vm.trust = $sce.trustAsHtml;
vm.newRandom = Math.random();
vm.address = {
city: "",
state: "",
country: ""
}
vm.seminar = {
StatusId: 2,
CategoryID: null,
CurrencyConversionTypeID: 0,
SeatsLeft: 0,
SeatsTotal: 20,
Date: new Date(),
IsOnline: false,
IsOnDemand: false,
CreatedDate: new Date(),
LastUpdated: new Date()
};
vm.seminarTypeId = 1;
vm.seminarType = [{ name: 'Workshop', id: 1 }, { name: 'Webinar', id: 2 }, { name: 'OnDemand', id: 3 }];
vm.seminarStatus = [{ name: 'Confirmed', id: 1 }, { name: 'Unconfirmed', id: 2 }, { name: 'Preregister', id: 4 }, { name: 'Disabled', id: 3 }];
vm.currencyConversionType = [{ name: 'Manual', id: 0 }, { name: 'Peg To BTC', id: 1 }, { name: 'Peg To USD', id: 2 }];
vm.exchange = "bitstamp";
vm.categories = [];
vm.datepicker = {};
vm.dateOptions = {
formatYear: 'yy',
startingDay: 1,
showWeeks: false
};
vm.openDatePicker = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker.opened = true;
};
vm.create = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
if (vm.seminarTypeId == 1) {
if (validateLocation() == false) return;
vm.seminar.Location = parseLocation();
}
vm.seminar.Date = parseDate();
vm.seminar.StreamURL = $('#summernote1').summernote('code');
vm.seminar.Description = $('#summernote2').summernote('code');
setSeminarType();
if (vm.seminarTypeId == 3) vm.seminar.Location = 'EA';
if (vm.seminar.Title == null || vm.seminar.Title == "") {
vm.seminar.Title = vm.seminar.Location
}
if (vm.seminar.Location == null || vm.seminar.Title == "") {
vm.seminar.Location = vm.seminar.Title
}
if (vm.seminar.CurrencyConversionTypeID > 0) {
setPrices();
}
else {
apiService.post('/api/seminars/add', vm.seminar,
createSucceded,
createFailed);
}
};
vm.prepareFiles = function ($files) {
seminarImage = $files;
};
function setPrices(result) {
bitcoinService.getBTCPrice(
getBTCPriceCompleted,
createFailed,
true
);
}
function getBTCPriceCompleted(result) {
//get price by exchange
var data = result.data.data;
var priceByExchange = data.prices.filter(function (obj) {
return obj.exchange === vm.exchange;
});
//convert prices
var spotPrice = roundUp(priceByExchange[0].price, 0);
if (vm.seminar.CurrencyConversionTypeID == 1) {
vm.seminar.PriceFiat = $filter('btcToUsd')(vm.seminar.Price, spotPrice);
}
else if (vm.seminar.CurrencyConversionTypeID == 2) {
vm.seminar.Price = $filter('usdToBtc')(vm.seminar.PriceFiat, spotPrice);;
}
//add seminar
apiService.post('/api/seminars/add', vm.seminar,
createSucceded,
createFailed);
}
function createSucceded(response) {
notificationService.displaySuccess('Successfully added workshop');
sessionStorage.removeItem('/api/seminars/public');
if (seminarImage) {
fileUploadService.uploadImage(seminarImage, 'seminar', response.data.seminarId, redirectToList);
}
else {
redirectToList();
}
}
function loadCategories() {
var url = '/api/categories/all';
apiService.get(url, null,
loadCategoriesCompleted,
loadFailed
);
}
function loadCategoriesCompleted(result) {
vm.categories = result.data;
vm.categories.push({ ID: null, Title: 'Select Category' });
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
function setSeminarType() {
if (vm.seminarTypeId == 1) {
vm.seminar.IsOnline = false;
vm.seminar.IsOnDemand = false;
}
else if (vm.seminarTypeId == 2) {
vm.seminar.IsOnline = true;
vm.seminar.IsOnDemand = false;
}
else if (vm.seminarTypeId == 3) {
vm.seminar.IsOnline = false;
vm.seminar.IsOnDemand = true;
}
}
function redirectToList() {
$location.path('/admin/workshop');
}
function createFailed (response) {
notificationService.displayError(response.data.Message);
}
function loadSummerNote() {
$(document).ready(function () {
setTimeout(function () {
$(".loadingSummerNote").hide();
$('#summernote1').summernote({
toolbar: [
['style', ['bold', 'underline', 'italic', 'strikethrough']],
['para', ['ul', 'ol']],
['insert', ['video', 'link']],
['misc', ['undo', 'redo']],
['fullscreen', ['fullscreen', 'codeview', 'help']],
]
});
$('#summernote2').summernote({
toolbar: [
['style', ['bold', 'underline', 'italic', 'strikethrough']],
['para', ['ul', 'ol']],
['insert', ['video', 'link']],
['misc', ['undo', 'redo']],
['fullscreen', ['fullscreen', 'codeview', 'help']],
]
});
$('.note-btn').removeAttr('data-original-title');
}, 1000);
});
}
function validateLocation() {
var isValid = true;
if (vm.address.country == '' || vm.address.country == undefined) {
$scope.sForm.country.$setValidity("valid", false);
isValid = false;
}
else {
$scope.sForm.country.$setValidity("valid", true);
}
if (vm.address.country == 'US' && vm.address.state == '') {
$scope.sForm.state.$setValidity("valid", false);
isValid = false;
}
else {
$scope.sForm.state.$setValidity("valid", true);
}
return isValid;
}
function parseLocation() {
var location = vm.address.city + ', ';
if (vm.address.country == 'US') {
location += vm.address.state + ', ' + vm.address.country
}
else {
location += vm.address.country
}
return location;
}
function parseDate() {
var date = new Date(vm.seminar.Date);
date.setHours(0, 0, 0); // Set hours, minutes and seconds
return new Date(date.toString());
}
loadSummerNote();
loadCategories();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('editSeminarCtrl', editSeminarCtrl);
editSeminarCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', '$filter', '$sce', 'apiService', 'bitcoinService', 'fileUploadService', 'NgTableParams', 'notificationService'];
function editSeminarCtrl($scope, $rootScope, $routeParams, $location, $modal, $filter, $sce, apiService, bitcoinService, fileUploadService, NgTableParams, notificationService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-edit-seminar';
var vm = this;
var seminarImage = null;
vm.trust = $sce.trustAsHtml;
vm.isLoading = true;
vm.newRandom = Math.random();
vm.address = {
city: "",
state: "",
country: ""
}
vm.seminar = {};
vm.seminarTypeId = 1;
vm.seminarType = [{ name: 'Workshop', id: 1 }, { name: 'Webinar', id: 2 }, { name: 'OnDemand', id: 3 }];
vm.seminarStatus = [{ name: 'Confirmed', id: 1 }, { name: 'Unconfirmed', id: 2 }, { name: 'Pregister', id: 4 }, { name: 'Completed', id: 5 }, { name: 'Disabled', id: 3 }];
vm.currencyConversionType = [{ name: 'Manual', id: 0 }, { name: 'Peg To BTC', id: 1 }, { name: 'Peg To USD', id: 2 }];
vm.exchange = "bitstamp";
vm.categories = [];
vm.orders = [];
vm.ordersTable = null;
vm.totalRecords = 0;
vm.containsPreregistered = [];
vm.datepicker = {};
vm.dateOptions = {
formatYear: 'yy',
startingDay: 1,
showWeeks: false
};
vm.closePage = function () {
var prevPage = window.location.href;
window.history.go(-1);
setTimeout(function () {
if (window.location.href == prevPage) {
window.close();
}
}, 500);
};
vm.edit = function (order) {
var full = location.protocol + '//' + location.hostname + (location.port ? ':' + location.port : '');
var url = full + '/admin/orders/edit/' + order.ID;
window.open(url, '_blank');
}
vm.editCustomer = function (order) {
var full = location.protocol + '//' + location.hostname + (location.port ? ':' + location.port : '');
var url = full + '/admin/customers/edit/' + order.CustomerID;
window.open(url, '_blank');
}
vm.openDatePicker = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker.opened = true;
};
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
if (vm.seminarTypeId == 1) {
if (validateLocation() == false) return;
vm.seminar.Location = parseLocation();
}
vm.seminar.Date = parseDate();
vm.seminar.StreamURL = $('#summernote1').summernote('code');
vm.seminar.Description = $('#summernote2').summernote('code');
setSeminarType();
if (vm.seminarTypeId == 3) vm.seminar.Location = 'EA';
if (seminarImage) {
fileUploadService.uploadImage(seminarImage, 'seminar', vm.seminar.ID, seminarImageCompleted);
}
else {
if (vm.seminar.CurrencyConversionTypeID > 0) {
setPrices();
}
else {
update();
}
}
};
vm.askDelete = function (item) {
var modalHtml = 'Are you sure you want to delete this?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
remove();
});
};
vm.prepareFiles = function ($files) {
seminarImage = $files;
};
vm.emailPreregisteredCustomers = function () {
emailPreregisteredCustomers();
};
vm.emailVenueInformation = function () {
emailVenueInformation();
};
vm.emailSeminarStreamURL = function () {
emailSeminarStreamURL();
};
vm.emailSeminarPreStreamURL = function () {
emailSeminarPreStreamURL();
};
function setPrices(result) {
bitcoinService.getBTCPrice(
getBTCPriceCompleted,
updateFailed,
true
);
}
function getBTCPriceCompleted(result) {
//get price by exchange
var data = result.data.data;
var priceByExchange = data.prices.filter(function (obj) {
return obj.exchange === vm.exchange;
});
//convert prices
var spotPrice = roundUp(priceByExchange[0].price, 0);
if (vm.seminar.CurrencyConversionTypeID == 1) {
vm.seminar.PriceFiat = $filter('btcToUsd')(vm.seminar.Price, spotPrice);
}
else if (vm.seminar.CurrencyConversionTypeID == 2) {
vm.seminar.Price = $filter('usdToBtc')(vm.seminar.PriceFiat, spotPrice);;
}
//update seminar
update();
}
function loadData() {
var url = '/api/seminars/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function loadOrders() {
apiService.get('/api/orders/seminar/' + vm.seminar.ID, null,
loadOrdersCompleted,
loadFailed);
}
function update() {
apiService.put('/api/seminars/update', vm.seminar,
updateSucceeded,
updateFailed);
}
function remove() {
var url = '/api/seminars/delete';
apiService.post(url, vm.seminar,
deleteSucceeded,
updateFailed
);
}
function emailPreregisteredCustomers() {
apiService.put('/api/orders/email/seminarconfirmed/batch', vm.seminar,
emailPreregisteredCustomersSucceeded,
updateFailed);
}
function emailVenueInformation() {
apiService.put('/api/orders/email/seminarvenue', vm.seminar,
emailVenueInformationSucceeded,
updateFailed);
}
function emailVenueInformationSucceeded(response) {
notificationService.displaySuccess('Successfully sent venue information');
}
function emailPreregisteredCustomersSucceeded(response) {
notificationService.displaySuccess('Successfully sent email to all pre-registered customers');
}
function loadCompleted(result) {
vm.seminar = result.data;
if (vm.seminar.Title == null || vm.seminar.Title == "") {
vm.seminar.Title = vm.seminar.Location
}
if (vm.seminar.Location == null || vm.seminar.Title == "") {
vm.seminar.Location = vm.seminar.Title
}
vm.address = formatLocation(vm.seminar.Location);
loadSeminarType();
loadSummerNote();
loadCategories();
loadOrders();
}
function loadOrdersCompleted(result) {
vm.orders = result.data;
vm.totalRecords = vm.orders.length;
var tableParams = { page: 1, count: vm.orders.length, sorting: {} }
vm.ordersTable = new NgTableParams(tableParams, { counts: [], total: vm.orders.length, dataset: vm.orders });
vm.containsPreregistered = $filter('filter')(vm.seminar.Orders, { StatusId: 4 }, true);
vm.isLoading = false;
}
function loadSeminarType() {
if (vm.seminar.IsOnline == false && vm.seminar.IsOnDemand == false) vm.seminarTypeId = 1;
else if (vm.seminar.IsOnline) vm.seminarTypeId = 2;
else if (vm.seminar.IsOnDemand) vm.seminarTypeId = 3;
}
function loadSummerNote() {
$(document).ready(function () {
setTimeout(function () {
$(".loadingSummerNote").hide();
$('#summernote1').summernote({
toolbar: [
['style', ['bold', 'underline', 'italic', 'strikethrough']],
['para', ['ul', 'ol']],
['insert', ['video', 'link']],
['misc', ['undo', 'redo']],
['fullscreen', ['fullscreen', 'codeview', 'help']],
]
});
$('#summernote2').summernote({
toolbar: [
['style', ['bold', 'underline', 'italic', 'strikethrough']],
['para', ['ul', 'ol']],
['insert', ['video', 'link']],
['misc', ['undo', 'redo']],
['fullscreen', ['fullscreen', 'codeview', 'help']],
]
});
$('.note-btn').removeAttr('data-original-title');
}, 1000);
});
}
function loadCategories() {
var url = '/api/categories/all';
apiService.get(url, null,
loadCategoriesCompleted,
loadFailed
);
}
function loadCategoriesCompleted(result) {
vm.categories = result.data;
vm.categories.push({ ID: null, Title: 'Select Category' });
vm.loadingSeminars = false;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function seminarImageCompleted() {
update();
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully updated workshop');
$scope.sForm.$setPristine();
sessionStorage.removeItem('/api/seminars/public');
vm.isLoading = true;
loadData();
}
function emailSeminarPreStreamURL() {
apiService.put('/api/orders/email/seminarprestreamurl/batch', vm.seminar,
emailSeminarPreStreamURLSucceeded,
updateFailed);
}
function emailSeminarPreStreamURLSucceeded(response) {
notificationService.displaySuccess('Successfully sent meeting link to customers');
}
function emailSeminarStreamURL() {
apiService.put('/api/orders/email/seminarstreamurl/batch', vm.seminar,
emailSeminarStreamURLSucceeded,
updateFailed);
}
function emailSeminarStreamURLSucceeded(response) {
notificationService.displaySuccess('Successfully sent Youtube link to customers');
}
function deleteSucceeded(response) {
notificationService.displaySuccess('Successfully deleted workshop');
$location.path('/admin/workshop');
}
function updateFailed (response) {
notificationService.displayError(response.data.Message);
}
function setSeminarType() {
if (vm.seminarTypeId == 1) {
vm.seminar.IsOnline = false;
vm.seminar.IsOnDemand = false;
}
else if (vm.seminarTypeId == 2) {
vm.seminar.IsOnline = true;
vm.seminar.IsOnDemand = false;
}
else if (vm.seminarTypeId == 3) {
vm.seminar.IsOnline = false;
vm.seminar.IsOnDemand = true;
}
}
function validateLocation() {
var isValid = true;
if (vm.address.country == '' || vm.address.country == undefined) {
$scope.sForm.country.$setValidity("valid", false);
isValid = false;
}
else {
$scope.sForm.country.$setValidity("valid", true);
}
if (vm.address.country == 'US' && vm.address.state == '') {
$scope.sForm.state.$setValidity("valid", false);
isValid = false;
}
else {
$scope.sForm.state.$setValidity("valid", true);
}
return isValid;
}
function parseLocation() {
var location = vm.address.city + ', ';
if (vm.address.country == 'US') {
location += vm.address.state + ', ' + vm.address.country
}
else {
location += vm.address.country
}
return location;
}
function formatLocation(location) {
var objLocation = {
city: '',
state: '',
country: ''
}
//location = location.toLowerCase();
if (vm.seminar.IsOnline) {
objLocation.city = ''
objLocation.state = '';
objLocation.country = 'US';
}
else {
var split = location.split(',');
if (split.length == 3) {
objLocation.city = split[0];
objLocation.state = split[1].replace(/[\. ,:-]+/g, "");
objLocation.country = split[2].replace(/[\. ,:-]+/g, "");
}
else if (split.length == 2) {
objLocation.city = split[0];
objLocation.country = split[1].replace(/[\. ,:-]+/g, "");
}
else if (split.length == 1) {
objLocation.country = split[0].replace(/[\. ,:-]+/g, "");
}
}
return objLocation;
}
function parseDate() {
var date = new Date(vm.seminar.Date);
date.setHours(0, 0, 0); // Set hours, minutes and seconds
return new Date(date.toString());
}
loadData();
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('seminarsCtrl', seminarsCtrl);
seminarsCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', '$q', 'seminarsService', 'notificationService', 'NgTableParams'];
function seminarsCtrl($scope, $rootScope, $filter, $location, $q, seminarsService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-seminars';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.firstRun = true;
vm.seminarsTable = null;
vm.seminars = [];
vm.filter = "";
vm.statusId = "";
vm.isOnline = "";
vm.isOnDemand = "";
vm.page = 0;
vm.pageSize = 10;
vm.pagesCount = 0;
vm.totalCount = 0;
vm.edit = function (seminar) {
var fullPath = window.location.href + '/edit/' + seminar.ID;
fullPath = fullPath.replace('workshop', 'workshops');
window.open(fullPath, '_blank');
//$location.path('/admin/workshops/edit/' + seminar.ID);
}
vm.pageChanged = function () {
search(vm.page);
};
vm.changePageSize = function () {
vm.page = 0;
search(0, true);
};
function search(page, reloadTable) {
if (reloadTable == true) {
vm.seminarsTable.reload();
}
else {
vm.seminarsTable.page(page);
}
}
vm.tableParams = { page: vm.page, count: vm.pageSize, sorting: {} }
vm.seminarsTable = new NgTableParams(vm.tableParams, {
counts: [], total: vm.totalCount,
getData: function (params) {
var order = params.orderBy().toString();
var orderBy = order.charAt(1).toUpperCase().length > 0 ? order.charAt(1).toUpperCase() + order.slice(2) : "";
var orderByDirection = order.charAt(0) == "+" ? "asc" : "desc";
var config = {
params: {
page: vm.page == 0 ? vm.page : vm.page - 1,
pageSize: vm.pageSize,
orderBy: orderBy,
orderByDirection: orderByDirection,
filter: vm.filter,
statusId: vm.statusId,
isOnline: vm.isOnline,
isOnDemand: false
}
};
return seminarsService.getSeminars(config).then(function (result) {
vm.seminars = result.Items;
vm.pagesCount = result.TotalPages;
vm.totalCount = result.TotalCount;
return vm.seminars;
});
}
});
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
function watch() {
$scope.$watch('[vm.filter, vm.statusId, vm.isOnline]', function (val) {
if (!vm.firstRun) {
if (vm.filter != '' && vm.filter.length > 2) {
search(0, true);
}
else if (vm.filter == '') {
search(0, true);
}
else {
//do nothing
}
}
vm.firstRun = false;
});
}
watch();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('ondemandCtrl', ondemandCtrl);
ondemandCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', '$q', 'seminarsService', 'notificationService', 'NgTableParams'];
function ondemandCtrl($scope, $rootScope, $filter, $location, $q, seminarsService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-ondemand';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.firstRun = true;
vm.seminarsTable = null;
vm.seminars = [];
vm.filter = "";
vm.statusId = "";
vm.isOnline = "";
vm.isOnDemand = "";
vm.page = 0;
vm.pageSize = 10;
vm.pagesCount = 0;
vm.totalCount = 0;
vm.edit = function (seminar) {
var fullPath = window.location.href + '/edit/' + seminar.ID;
fullPath = fullPath.replace('workshop', 'workshops');
window.open(fullPath, '_blank');
//$location.path('/admin/workshops/edit/' + seminar.ID);
}
vm.pageChanged = function () {
search(vm.page);
};
vm.changePageSize = function () {
vm.page = 0;
search(0, true);
};
function search(page, reloadTable) {
if (reloadTable == true) {
vm.seminarsTable.reload();
}
else {
vm.seminarsTable.page(page);
}
}
vm.tableParams = { page: vm.page, count: vm.pageSize, sorting: {} }
vm.seminarsTable = new NgTableParams(vm.tableParams, {
counts: [], total: vm.totalCount,
getData: function (params) {
var order = params.orderBy().toString();
var orderBy = order.charAt(1).toUpperCase().length > 0 ? order.charAt(1).toUpperCase() + order.slice(2) : "";
var orderByDirection = order.charAt(0) == "+" ? "asc" : "desc";
var config = {
params: {
page: vm.page == 0 ? vm.page : vm.page - 1,
pageSize: vm.pageSize,
orderBy: orderBy,
orderByDirection: orderByDirection,
filter: vm.filter,
statusId: vm.statusId,
isOnline: false,
isOnDemand: true
}
};
return seminarsService.getSeminars(config).then(function (result) {
vm.seminars = result.Items;
vm.pagesCount = result.TotalPages;
vm.totalCount = result.TotalCount;
return vm.seminars;
});
}
});
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
function watch() {
$scope.$watch('[vm.filter, vm.statusId]', function (val) {
if (!vm.firstRun) {
if (vm.filter != '' && vm.filter.length > 2) {
search(0, true);
}
else if (vm.filter == '') {
search(0, true);
}
else {
//do nothing
}
}
vm.firstRun = false;
});
}
watch();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('addEmailCampaignCtrl', addEmailCampaignCtrl);
addEmailCampaignCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$sce', 'apiService', 'notificationService'];
function addEmailCampaignCtrl($scope, $rootScope, $routeParams, $location, $sce, apiService, notificationService) {
$scope.pageClass = 'page-admin-add-email-campaign';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.isLoading = true;
vm.emailCampaign = {
StatusId: 1,
EmailID: "0",
SentDate: null,
CreatedDate: new Date()
};
vm.trust = $sce.trustAsHtml;
vm.emails = [];
vm.create = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
console.info(field);
angular.forEach(field, function (errorField) {
console.info(errorField);
errorField.$setDirty();
})
});
return;
}
apiService.post('/api/emailcampaigns/add', vm.emailCampaign,
createSucceded,
createFailed);
};
function createSucceded(response) {
notificationService.displaySuccess('Successfully added campaign');
vm.emailCampaign = response.data;
$location.path('/admin/emailcampaigns');
}
function createFailed(response) {
notificationService.displayError(response.data.Message);
}
function loadEmails() {
apiService.get('/api/emails/type/2', null,
loadEmailsCompleted,
loadFailed
);
}
function loadEmailsCompleted(result) {
vm.emails = result.data;
vm.emails.push({ ID: "0", Subject: 'Select Email' });
vm.isLoading = false;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
loadEmails();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('editEmailCampaignCtrl', editEmailCampaignCtrl);
editEmailCampaignCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$filter', '$modal', '$sce', 'apiService', 'notificationService'];
function editEmailCampaignCtrl($scope, $rootScope, $routeParams, $location, $filter, $modal, $sce, apiService, notificationService) {
$scope.pageClass = 'page-admin-edit-email-campaign';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.isLoading = true;
vm.emailCampaign = {};
vm.selectedEmail = {};
vm.trust = $sce.trustAsHtml;
vm.emails = [];
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
update();
};
vm.askDelete = function (item) {
var modalHtml = 'Are you sure you want to delete this?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
remove();
});
};
function update() {
apiService.put('/api/emailcampaigns/update', vm.emailCampaign,
updateSucceeded,
updateFailed);
}
function loadEmails() {
apiService.get('/api/emails/type/2', null,
loadEmailsCompleted,
loadFailed
);
}
function loadEmailsCompleted(result) {
vm.emails = result.data;
vm.emails.push({ ID: null, Subject: 'Select Email' });
loadData();
}
function loadData() {
var url = '/api/emailcampaigns/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function remove() {
var url = '/api/emailcampaigns/delete';
apiService.post(url, vm.emailCampaign,
deleteSucceeded,
updateFailed
);
}
function loadCompleted(result) {
vm.emailCampaign = result.data;
var found = $filter('filter')(vm.emails, { ID: vm.emailCampaign.EmailID }, true);
if (found.length) {
vm.selectedEmail = found[0];
}
vm.isLoading = false;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully updated email');
$scope.sForm.$setPristine();
}
function deleteSucceeded(response) {
notificationService.displaySuccess('Successfully deleted campaign');
$location.path('/admin/emailcampaigns');
}
function updateFailed (response) {
notificationService.displayError(response);
}
loadEmails();
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('emailCampaignsCtrl', emailCampaignsCtrl);
emailCampaignsCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', 'apiService', 'notificationService', 'NgTableParams'];
function emailCampaignsCtrl($scope, $rootScope, $filter, $location, apiService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-email-campaigns';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.campaignsTable = null;
vm.campaigns = [];
vm.filter = "";
vm.statusId = "";
vm.page = 0;
vm.pageSize = 100;
vm.pagesCount = 0;
vm.totalCount = 0;
vm.edit = function (campaign) {
$location.path('/admin/emailcampaigns/edit/' + campaign.ID);
}
vm.pageChanged = function () {
search(vm.page - 1);
};
function search(page) {
page = page || 0;
var config = {
params: {
page: page,
pageSize: vm.pageSize,
filter: vm.filter,
statusId: vm.statusId
}
};
apiService.get('/api/emailcampaigns/', config,
loadCompleted,
loadFailed);
}
function loadCompleted(result) {
vm.campaigns = result.data.Items;
vm.pagesCount = result.data.TotalPages;
vm.totalCount = result.data.TotalCount;
var tableParams = { page: 1, count: vm.pageSize, sorting: {name: 'asc'}}
vm.campaignsTable = new NgTableParams(tableParams, { counts: [], total: vm.totalCount, dataset: vm.campaigns });
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
function watch() {
$scope.$watch('[vm.filter, vm.statusId]', function (val) {
if (val != '' && val != undefined && val.length > 2) {
search();
} else {
search(0);
}
});
}
watch();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('startEmailCampaignCtrl', startEmailCampaignCtrl);
startEmailCampaignCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', '$filter', 'apiService', 'NgTableParams', 'notificationService'];
function startEmailCampaignCtrl($scope, $rootScope, $routeParams, $location, $modal, $filter, apiService, NgTableParams, notificationService) {
$scope.pageClass = 'page-admin-start-email-campaign';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.isLoading = true;
vm.isSending = false;
vm.startButtonText = "Start Email Campaign";
vm.emailCampaign = {};
vm.emailCampaigns = [];
vm.query = {
ItemID: "0",
EmailCampaignID: "0"
};
vm.selectEmailCampaign = function () {
selectEmailCampaign();
};
vm.startEmailCampaign = function () {
if (!vm.query.AllCustomers && !vm.query.SeminarCustomers && !vm.query.ProductCustomers && !vm.query.ConferenceCustomers) {
return;
}
else {
startEmailCampaign();
}
};
vm.selectAllCustomers = function () {
if (vm.query.AllCustomers) {
vm.query.SeminarCustomers = false;
vm.query.ProductCustomers = false;
vm.query.ConferenceCustomers = false;
vm.query.SubscriptionCustomers = false;
}
};
function selectEmailCampaign() {
var found = $filter('filter')(vm.emailCampaigns, { ID: vm.query.EmailCampaignID }, true);
if (found.length) {
vm.emailCampaign = found[0];
}
}
function startEmailCampaign() {
vm.isSending = true;
vm.startButtonText = "Sending...";
apiService.put('/api/emailcampaigns/start', vm.query,
startSucceeded,
startFailed);
}
function loadData() {
var url = '/api/emailcampaigns/ready';
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function loadCompleted(result) {
vm.emailCampaigns = result.data;
vm.emailCampaigns.push({ ID: "0", Title: 'Select Ready Campaign' });
vm.isLoading = false;
loadSeminars();
loadProducts();
loadConferences();
loadSubscriptions();
}
function loadSeminars() {
var url = '/api/seminars/all';
apiService.get(url, null,
loadSeminarsCompleted,
loadFailed
);
}
function loadSeminarsCompleted(result) {
vm.isLoading = false;
vm.seminars = result.data;
vm.seminars.push({ ID: "0", LocationAndId: 'All Workshops' });
vm.seminarsLoaded = true;
}
function loadProducts() {
var url = '/api/products/all';
apiService.get(url, null,
loadProductsCompleted,
loadFailed
);
}
function loadProductsCompleted(result) {
vm.products = result.data;
vm.products.push({ ID: "0", Title: 'All Products' });
}
function loadConferences() {
var url = '/api/conferences/all';
apiService.get(url, null,
loadConferencesCompleted,
loadFailed
);
}
function loadConferencesCompleted(result) {
vm.conferences = result.data;
vm.conferences.push({ ID: "0", Title: 'All Conferences' });
}
function loadSubscriptions() {
var url = '/api/subscriptions/all';
apiService.get(url, null,
loadSubscriptionsCompleted,
loadFailed
);
}
function loadSubscriptionsCompleted(result) {
vm.isLoading = false;
vm.subscriptions = result.data;
vm.subscriptions.push({ ID: "0", Title: 'All Subscriptions' });
vm.subscriptionsLoaded = true;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function startSucceeded(response) {
notificationService.displaySuccess('Successfully sent emails');
$location.path('/admin/emailcampaigns/edit/' + vm.query.EmailCampaignID);
}
function startFailed(response) {
vm.isSending = false;
vm.startButtonText = "Start Email Campaign";
notificationService.displayError(response.data.Message);
}
loadData();
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('campaignEmailsCtrl', campaignEmailsCtrl);
campaignEmailsCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', 'apiService', 'notificationService', 'NgTableParams'];
function campaignEmailsCtrl($scope, $rootScope, $filter, $location, apiService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-campaign-emails';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.emailContentTable = null;
vm.emails = [];
vm.isLoading = true;
vm.totalRecords = 0;
vm.edit = function (email) {
$location.path('/admin/emailcampaigns/emails/edit/' + email.ID);
}
function loadData() {
var url = '/api/emails/type/2';
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function loadCompleted(result) {
vm.emails = result.data;
vm.totalRecords = vm.emails.length;
vm.isLoading = false;
var tableParams = { page: 1, count: 100, sorting: {}}
vm.emailContentTable = new NgTableParams(tableParams, { counts: [], total: vm.emails.length, dataset: vm.emails });
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
loadData();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('addCampaignEmailCtrl', addCampaignEmailCtrl);
addCampaignEmailCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$sce', '$location', 'apiService', 'NgTableParams', 'notificationService'];
function addCampaignEmailCtrl($scope, $rootScope, $routeParams, $sce, $location, apiService, NgTableParams, notificationService) {
$scope.pageClass = 'page-admin-add-campaign-email';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.email = {
EmailTypeId: 2,
CreatedDate: new Date()
};
vm.trust = $sce.trustAsHtml;
vm.create = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
vm.email.Body = $('#summernote').summernote('code');
apiService.post('/api/emails/add', vm.email,
createSucceded,
createFailed);
};
function loadSummerNote() {
$(document).ready(function () {
setTimeout(function () {
$("#loadingSummerNote").hide();
$('#summernote').summernote({
fontSizes: ['8', '9', '10', '11', '12', '14', '16', '18', '24', '36', '48'],
toolbar: [
['header', ['style']],
['style', ['bold', 'underline', 'italic', 'strikethrough']],
['font', ['fontsize', 'color']],
['para', ['ul', 'ol', 'paragraph']],
['table', ['table']],
['insert', ['imageButton', 'video', 'link']],
['misc', ['undo', 'redo']],
['fullscreen', ['fullscreen', 'codeview', 'help']],
],
buttons: {
imageButton: ImageButton
}
});
$('.note-btn').removeAttr('data-original-title');
}, 1000);
});
}
function createSucceded(response) {
notificationService.displaySuccess('Successfully added campaign email');
vm.emailCampaign = response.data;
$location.path('/admin/emailcampaigns/emails');
}
function createFailed(response) {
notificationService.displayError(response.data.Message);
}
loadSummerNote();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('editCampaignEmailCtrl', editCampaignEmailCtrl);
editCampaignEmailCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$sce', '$modal', '$location', 'apiService', 'NgTableParams', 'notificationService'];
function editCampaignEmailCtrl($scope, $rootScope, $routeParams, $sce, $modal, $location, apiService, NgTableParams, notificationService) {
$scope.pageClass = 'page-admin-edit-campaign-email';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.isLoading = true;
vm.email = {};
vm.trust = $sce.trustAsHtml;
vm.emailCampaignsTable = null;
vm.emailCampaigns = [];
vm.totalCount = 0;
vm.edit = function (campaign) {
$location.path('/admin/emailcampaigns/edit/' + campaign.ID);
}
vm.sendTest = function () {
sendTest();
}
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
vm.email.Body = $('#summernote').summernote('code');
update();
};
vm.askDelete = function (item) {
var modalHtml = 'Are you sure you want to delete this?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
remove();
});
};
function loadEmailCampaigns() {
vm.emailCampaigns = vm.email.EmailCampaigns;
vm.totalCount = vm.emailCampaigns.length;
vm.isLoading = false;
var tableParams = { page: 1, count: 10, sorting: {} }
vm.emailCampaignsTable = new NgTableParams($scope.tableParams, { counts: [], total: vm.emailCampaigns.length, dataset: vm.emailCampaigns });
}
function loadData() {
var url = '/api/emails/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function loadCompleted(result) {
vm.email = result.data;
loadSummerNote();
if (vm.email.EmailCampaigns.length > 0) {
loadEmailCampaigns();
}
vm.isLoading = false;
}
function loadSummerNote() {
$(document).ready(function () {
setTimeout(function () {
$("#loadingSummerNote").hide();
$('#summernote').summernote({
fontSizes: ['8', '9', '10', '11', '12', '14', '16', '18', '24', '36', '48'],
toolbar: [
['header', ['style']],
['style', ['bold', 'underline', 'italic', 'strikethrough']],
['font', ['fontsize', 'color']],
['para', ['ul', 'ol', 'paragraph']],
['table', ['table']],
['insert', ['imageButton', 'video', 'link']],
['misc', ['undo', 'redo']],
['fullscreen', ['fullscreen', 'codeview', 'help']],
],
buttons: {
imageButton: ImageButton
}
});
$('.note-btn').removeAttr('data-original-title');
}, 1000);
});
}
function update() {
apiService.put('/api/emails/update', vm.email,
updateSucceeded,
updateFailed);
}
function remove() {
var url = '/api/emails/delete';
apiService.post(url, vm.email,
deleteSucceeded,
updateFailed
);
}
function sendTest() {
apiService.put('/api/emailcampaigns/sendtest', vm.email,
emailSucceeded,
updateFailed);
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function emailSucceeded(response) {
notificationService.displaySuccess('Successfully sent email');
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully updated email');
$scope.sForm.$setPristine();
}
function deleteSucceeded(response) {
notificationService.displaySuccess('Successfully deleted email');
$location.path('/admin/emailcampaigns/emails');
}
function updateFailed (response) {
notificationService.displayError(response);
}
loadData();
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('addConferenceProductCtrl', addConferenceProductCtrl);
addConferenceProductCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$filter', '$sce', 'apiService', 'bitcoinService', 'notificationService', 'fileUploadService'];
function addConferenceProductCtrl($scope, $rootScope, $routeParams, $location, $filter, $sce, apiService, bitcoinService, notificationService, fileUploadService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-add-conference-product';
scrollToTop();
var vm = this;
vm.trust = $sce.trustAsHtml;
vm.conferenceProduct = {
StatusId: 1,
CurrencyConversionTypeID: 0,
ConferenceID: $routeParams.id,
EndDate: new Date(),
CreatedDate: new Date()
};
vm.datepicker = {};
vm.dateOptions = {
formatYear: 'yy',
startingDay: 1,
showWeeks: false
};
vm.productStatus = [{ name: 'Enabled', id: 1 }, { name: 'Disabled', id: 2 }];
vm.currencyConversionType = [{ name: 'Manual', id: 0 }, { name: 'Peg To BTC', id: 1 }, { name: 'Peg To USD', id: 2 }];
vm.exchange = "bitstamp";
vm.openDatePicker = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker.opened = true;
};
vm.create = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
console.info(field);
angular.forEach(field, function (errorField) {
console.info(errorField);
errorField.$setDirty();
})
});
return;
}
vm.conferenceProduct.Description = $('#summernote').summernote('code');
if (vm.conferenceProduct.CurrencyConversionTypeID > 0) {
setPrices();
}
else {
apiService.post('/api/conferenceproducts/add', vm.conferenceProduct,
createSucceded,
createFailed);
}
};
function setPrices(result) {
bitcoinService.getBTCPrice(
getBTCPriceCompleted,
createFailed,
true
);
}
function getBTCPriceCompleted(result) {
//get price by exchange
var spotPrice = roundUp(result.data, 0);
//convert
if (vm.conferenceProduct.CurrencyConversionTypeID == 1) {
vm.conferenceProduct.PriceFiat = $filter('btcToUsd')(vm.conferenceProduct.Price, spotPrice);
}
else if (vm.conferenceProduct.CurrencyConversionTypeID == 2) {
vm.conferenceProduct.Price = $filter('usdToBtc')(vm.conferenceProduct.PriceFiat, spotPrice);;
}
//add conference product
apiService.post('/api/conferenceproducts/add', vm.conferenceProduct,
createSucceded,
createFailed);
}
function createSucceded(response) {
notificationService.displaySuccess('Successfully added rate');
vm.conferenceProduct = response.data;
$location.path('/admin/conferences/edit/' + $routeParams.id);
}
function createFailed (response) {
notificationService.displayError(response.data.Message);
}
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('editConferenceProductCtrl', editConferenceProductCtrl);
editConferenceProductCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$filter', '$modal', '$http', '$sce', 'apiService', 'bitcoinService', 'NgTableParams', 'notificationService', 'fileUploadService'];
function editConferenceProductCtrl($scope, $rootScope, $routeParams, $location, $filter, $modal, $http, $sce, apiService, bitcoinService, NgTableParams, notificationService, fileUploadService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-edit-conference-product';
scrollToTop();
var vm = this;
vm.trust = $sce.trustAsHtml;
vm.isLoading = true;
vm.conferenceProduct = {};
vm.datepicker = {};
vm.dateOptions = {
formatYear: 'yy',
startingDay: 1,
showWeeks: false
};
vm.productStatus = [{ name: 'Enabled', id: 1 }, { name: 'Disabled', id: 2 }];
vm.currencyConversionType = [{ name: 'Manual', id: 0 }, { name: 'Peg To BTC', id: 1 }, { name: 'Peg To USD', id: 2 }];
vm.exchange = "bitstamp";
vm.openDatePicker = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker.opened = true;
};
vm.edit = function (order) {
var full = location.protocol + '//' + location.hostname + (location.port ? ':' + location.port : '');
var url = full + '/admin/orders/edit/' + order.ID;
window.open(url, '_blank');
}
vm.editCustomer = function (order) {
var full = location.protocol + '//' + location.hostname + (location.port ? ':' + location.port : '');
var url = full + '/admin/customers/edit/' + order.CustomerID;
window.open(url, '_blank');
}
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
vm.conferenceProduct.Description = $('#summernote').summernote('code');
if (vm.conferenceProduct.CurrencyConversionTypeID > 0) {
setPrices();
}
else {
update();
}
};
vm.askDelete = function (item) {
var modalHtml = 'Are you sure you want to delete this?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
remove();
});
};
vm.goToConference = function () {
$location.path('/admin/conferences/edit/' + vm.conferenceProduct.ConferenceID);
};
function setPrices(result) {
bitcoinService.getBTCPrice(
getBTCPriceCompleted,
updateFailed,
true
);
}
function getBTCPriceCompleted(result) {
//convert prices
var spotPrice = roundUp(result.data, 0);
console.log(spotPrice);
if (vm.conferenceProduct.CurrencyConversionTypeID == 1) {
vm.conferenceProduct.PriceFiat = $filter('btcToUsd')(vm.conferenceProduct.Price, spotPrice);
}
else if (vm.conferenceProduct.CurrencyConversionTypeID == 2) {
vm.conferenceProduct.Price = $filter('usdToBtc')(vm.conferenceProduct.PriceFiat, spotPrice);;
}
//update product
update();
}
function loadOrders() {
apiService.get('/api/orders/conferenceproduct/' + vm.conferenceProduct.ID, null,
loadOrdersCompleted,
loadFailed);
}
function loadData() {
var url = '/api/conferenceproducts/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function update() {
apiService.put('/api/conferenceproducts/update', vm.conferenceProduct,
updateSucceeded,
updateFailed);
}
function remove() {
var url = '/api/conferenceproducts/delete';
apiService.post(url, vm.conferenceProduct,
deleteSucceeded,
updateFailed
);
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully updated rate');
$scope.sForm.$setPristine();
vm.isLoading = true;
loadData();
}
function loadCompleted(result) {
vm.conferenceProduct = result.data;
loadOrders();
}
function loadOrdersCompleted(result) {
vm.orders = result.data;
vm.totalRecords = vm.orders.length;
var tableParams = { page: 1, count: vm.orders.length, sorting: {} }
vm.ordersTable = new NgTableParams(tableParams, { counts: [], total: vm.orders.length, dataset: vm.orders });
vm.isLoading = false;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function deleteSucceeded(response) {
notificationService.displaySuccess('Successfully deleted rate');
$location.path('/admin/conferences/edit/' + vm.conferenceProduct.Conference.ID);
}
function updateFailed (response) {
notificationService.displayError(response.data.Message);
}
loadData();
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('addConferenceCtrl', addConferenceCtrl);
addConferenceCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', 'apiService', 'notificationService', 'bitcoinService', 'fileUploadService'];
function addConferenceCtrl($scope, $rootScope, $routeParams, $location, apiService, notificationService, bitcoinService, fileUploadService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-add-conference';
var vm = this;
var conferenceImage = null;
vm.newRandom = Math.random();
vm.address = {
city: "",
state: "",
country: ""
}
vm.conference = {
StatusId: 2,
StartDate: new Date(),
EndDate: new Date(),
CreatedDate: new Date()
};
vm.conferenceStatus = [{ name: 'Confirmed', id: 1 }, { name: 'Unconfirmed', id: 2 }, { name: 'Disabled', id: 3 }];
vm.datepicker = {};
vm.datepicker2 = {};
vm.dateOptions = {
formatYear: 'yy',
startingDay: 1,
showWeeks: false
};
vm.openDatePicker = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker.opened = true;
};
vm.openDatePicker2 = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker2.opened = true;
};
vm.create = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
console.info(field);
angular.forEach(field, function (errorField) {
console.info(errorField);
errorField.$setDirty();
})
});
return;
}
vm.conference.Location = parseLocation();
apiService.post('/api/conferences/add', vm.conference,
createSucceded,
createFailed);
};
vm.prepareFiles = function ($files) {
conferenceImage = $files;
};
function createSucceded(response) {
notificationService.displaySuccess('Successfully added conference');
vm.conference = response.data;
sessionStorage.removeItem('/api/conferences');
if (conferenceImage) {
fileUploadService.uploadImage(conferenceImage, 'conference', vm.conference.ID, redirectToList);
}
else {
redirectToList();
}
}
function redirectToList() {
$location.path('/admin/conferences');
}
function parseLocation() {
var location = vm.address.city + ', ';
if (vm.address.country == 'US') {
location += vm.address.state + ', ' + vm.address.country
}
else {
location += vm.address.country
}
return location;
}
function createFailed (response) {
notificationService.displayError(response.data.Message);
}
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('editConferenceCtrl', editConferenceCtrl);
editConferenceCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', 'apiService', 'bitcoinService', 'NgTableParams', 'notificationService'];
function editConferenceCtrl($scope, $rootScope, $routeParams, $location, $modal, apiService, bitcoinService, NgTableParams, notificationService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-edit-conference';
var vm = this;
var conferenceImage = null;
vm.isLoading = true;
vm.newRandom = Math.random();
vm.conference = {};
vm.conferenceStatus = [{ name: 'Confirmed', id: 1 }, { name: 'Unconfirmed', id: 2 }, { name: 'Disabled', id: 3 }];
vm.currencyConversionType = [{ name: 'Manual', id: 0 }, { name: 'Peg To BTC', id: 1 }, { name: 'Peg To USD', id: 2 }];
vm.conferenceProductsTable = null;
vm.conferenceProducts = [];
vm.totalCount = 0;
vm.orderObjectResult = {};
vm.datepicker = {};
vm.datepicker2 = {};
vm.dateOptions = {
formatYear: 'yy',
startingDay: 1,
showWeeks: false
};
vm.openDatePicker = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker.opened = true;
};
vm.openDatePicker2 = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker2.opened = true;
};
vm.closePage = function () {
var prevPage = window.location.href;
window.history.go(-1);
setTimeout(function () {
if (window.location.href == prevPage) {
window.close();
}
}, 500);
};
vm.edit = function (conferenceProduct) {
$location.path('/admin/conferences/products/edit/' + conferenceProduct.ID);
}
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
vm.conference.Location = parseLocation();
update();
};
vm.askDelete = function (item) {
var modalHtml = 'Are you sure you want to delete this?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
remove();
});
};
vm.prepareFiles = function ($files) {
conferenceImage = $files;
};
vm.editCustomer = function (order) {
var full = location.protocol + '//' + location.hostname + (location.port ? ':' + location.port : '');
var url = full + '/admin/customers/edit/' + order.CustomerID;
window.open(url, '_blank');
};
function loadConferenceProducts() {
var url = '/api/conferenceproducts/conference/' + vm.conference.ID;
apiService.get(url, null,
loadConferenceProductsCompleted,
loadFailed
);
}
function loadConferenceProductsCompleted(result) {
vm.conferenceProducts = result.data;
vm.totalCount = vm.conferenceProducts.length;
vm.isLoading = false;
var tableParams = { page: 1, count: 10, sorting: {} }
vm.conferenceProductsTable = new NgTableParams($scope.tableParams, { counts: [], total: vm.conferenceProducts.length, dataset: vm.conferenceProducts });
}
function loadData() {
var url = '/api/conferences/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function loadOrders() {
apiService.get('/api/orders/conference/' + vm.conference.ID, null,
loadOrdersCompleted,
loadFailed);
}
function loadOrderObjectResult() {
var url = '/api/orders/validate/3/' + $routeParams.id;
apiService.get(url, null,
loadOrderObjectResultCompleted,
loadFailed
);
}
function update() {
apiService.put('/api/conferences/update', vm.conference,
updateSucceeded,
updateFailed);
}
function remove() {
var url = '/api/conferences/delete';
apiService.post(url, vm.conference,
deleteSucceeded,
updateFailed
);
}
function loadCompleted(result) {
vm.conference = result.data;
vm.address = formatLocation(vm.conference.Location);
loadConferenceProducts();
loadOrderObjectResult();
loadOrders();
}
function loadOrdersCompleted(result) {
vm.orders = result.data;
vm.totalRecords = vm.orders.length;
var tableParams = { page: 1, count: vm.orders.length, sorting: {} }
vm.ordersTable = new NgTableParams(tableParams, { counts: [], total: vm.orders.length, dataset: vm.orders });
vm.isLoading = false;
}
function loadOrderObjectResultCompleted(result) {
vm.orderObjectResult = result.data;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function parseLocation() {
var location = vm.address.city + ', ';
if (vm.address.country == 'US') {
location += vm.address.state + ', ' + vm.address.country
}
else {
location += vm.address.country
}
return location;
}
function formatLocation(location) {
var objLocation = {
city: '',
state: '',
country: ''
}
//location = location.toLowerCase();
var split = location.split(',');
if (split.length == 3) {
objLocation.city = split[0];
objLocation.state = split[1].replace(/[\. ,:-]+/g, "");
objLocation.country = split[2].replace(/[\. ,:-]+/g, "");
}
else if (split.length == 2) {
objLocation.city = split[0];
objLocation.country = split[1].replace(/[\. ,:-]+/g, "");
}
else if (split.length == 1) {
objLocation.country = split[0].replace(/[\. ,:-]+/g, "");
}
return objLocation;
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully confirmed conference');
$scope.sForm.$setPristine();
sessionStorage.removeItem('/api/conferences/all');
vm.isLoading = true;
loadData();
}
function deleteSucceeded(response) {
notificationService.displaySuccess('Successfully deleted conference');
$location.path('/admin/conferences');
}
function updateFailed(response) {
notificationService.displayError(response.data.Message);
}
loadData();
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('conferencesCtrl', conferencesCtrl);
conferencesCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', 'apiService', 'notificationService', 'NgTableParams'];
function conferencesCtrl($scope, $rootScope, $filter, $location, apiService, notificationService, NgTableParams) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-conferences';
var vm = this;
vm.conferencesTable = null;
vm.conferences = [];
vm.filter = "";
vm.statusId = "";
vm.page = 0;
vm.pageSize = 100;
vm.pagesCount = 0;
vm.totalCount = 0;
vm.edit = function (conference) {
var fullPath = window.location.href + '/edit/' + conference.ID;
window.open(fullPath, '_blank');
//$location.path('/admin/conferences/edit/' + conference.ID);
}
vm.pageChanged = function () {
search(vm.page - 1);
};
function search(page) {
page = page || 0;
var config = {
params: {
page: page,
pageSize: vm.pageSize,
filter: vm.filter,
statusId: vm.statusId
}
};
apiService.get('/api/conferences/', config,
loadCompleted,
loadFailed);
}
function loadCompleted(result) {
vm.conferences = result.data.Items;
vm.pagesCount = result.data.TotalPages;
vm.totalCount = result.data.TotalCount;
var tableParams = { page: 1, count: vm.pageSize, sorting: {name: 'asc'}}
vm.conferencesTable = new NgTableParams(tableParams, { counts: [], total: vm.totalCount, dataset: vm.conferences });
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
function watch() {
$scope.$watch('[vm.filter, vm.statusId]', function (val) {
if (val != '' && val != undefined && val.length > 2) {
search();
} else {
search(0);
}
});
}
watch();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('addSubscriptionProductCtrl', addSubscriptionProductCtrl);
addSubscriptionProductCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$sce', '$filter', 'apiService', 'bitcoinService', 'notificationService', 'fileUploadService'];
function addSubscriptionProductCtrl($scope, $rootScope, $routeParams, $location, $sce, $filter, apiService, bitcoinService, notificationService, fileUploadService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-add-subscription-product';
scrollToTop();
var vm = this;
vm.trust = $sce.trustAsHtml;
vm.subscriptionProduct = {
StatusId: 1,
CurrencyConversionTypeID: 0,
IntervalID: 1,
SubscriptionID: $routeParams.id,
CreatedDate: new Date(),
LastUpdated: new Date()
};
vm.datepicker = {};
vm.dateOptions = {
formatYear: 'yy',
startingDay: 1,
showWeeks: false
};
vm.productStatus = [{ name: 'Enabled', id: 1 }, { name: 'Disabled', id: 2 }];
vm.subscriptionIntervals = [{ name: 'Daily', id: 1 }, { name: 'Weekly', id: 2 }, { name: 'Monthly', id: 3 }, { name: 'Quarterly', id: 4 }, { name: 'Annually', id: 5 }, { name: 'Bi-Annually', id: 6 }];
vm.currencyConversionType = [{ name: 'Manual', id: 0 }, { name: 'Peg To BTC', id: 1 }, { name: 'Peg To USD', id: 2 }];
vm.exchange = "bitstamp";
vm.openDatePicker = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker.opened = true;
};
vm.create = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
console.info(field);
angular.forEach(field, function (errorField) {
console.info(errorField);
errorField.$setDirty();
})
});
return;
}
vm.subscriptionProduct.Description = $('#summernote').summernote('code');
if (vm.subscriptionProduct.CurrencyConversionTypeID > 0) {
setPrices();
}
else {
apiService.post('/api/subscriptionproducts/add', vm.subscriptionProduct,
createSucceded,
createFailed);
}
};
function setPrices(result) {
bitcoinService.getBTCPrice(
getBTCPriceCompleted,
createFailed,
true
);
}
function getBTCPriceCompleted(result) {
//get price by exchange
var data = result.data.data;
var priceByExchange = data.prices.filter(function (obj) {
return obj.exchange === vm.exchange;
});
//convert prices
var spotPrice = roundUp(priceByExchange[0].price, 0);
if (vm.subscriptionProduct.CurrencyConversionTypeID == 1) {
vm.subscriptionProduct.PriceFiat = $filter('btcToUsd')(vm.subscriptionProduct.Price, spotPrice);
}
else if (vm.subscriptionProduct.CurrencyConversionTypeID == 2) {
vm.subscriptionProduct.Price = $filter('usdToBtc')(vm.subscriptionProduct.PriceFiat, spotPrice);;
}
//add subsciption product
apiService.post('/api/subscriptionproducts/add', vm.subscriptionProduct,
createSucceded,
createFailed);
}
function createSucceded(response) {
notificationService.displaySuccess('Successfully added plan');
vm.subscriptionProduct = response.data;
$location.path('/admin/subscriptions/edit/' + $routeParams.id);
}
function createFailed (response) {
notificationService.displayError(response.data.Message);
}
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('editSubscriptionProductCtrl', editSubscriptionProductCtrl);
editSubscriptionProductCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', '$http', '$sce', '$filter', 'apiService', 'bitcoinService', 'NgTableParams', 'notificationService', 'fileUploadService'];
function editSubscriptionProductCtrl($scope, $rootScope, $routeParams, $location, $modal, $http, $sce, $filter, apiService, bitcoinService, NgTableParams, notificationService, fileUploadService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-edit-subscription-product';
scrollToTop();
var vm = this;
vm.trust = $sce.trustAsHtml;
vm.isLoading = true;
vm.subscriptionProduct = {};
vm.datepicker = {};
vm.dateOptions = {
formatYear: 'yy',
startingDay: 1,
showWeeks: false
};
vm.productStatus = [{ name: 'Enabled', id: 1 }, { name: 'Disabled', id: 2 }];
vm.subscriptionIntervals = [{ name: 'Daily', id: 1 }, { name: 'Weekly', id: 2 }, { name: 'Monthly', id: 3 }, { name: 'Quarterly', id: 4 }, { name: 'Annually', id: 5 }, { name: 'Bi-Annually', id: 6 }];
vm.currencyConversionType = [{ name: 'Manual', id: 0 }, { name: 'Peg To BTC', id: 1 }, { name: 'Peg To USD', id: 2 }];
vm.exchange = "bitstamp";
vm.openDatePicker = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker.opened = true;
};
vm.edit = function (order) {
var full = location.protocol + '//' + location.hostname + (location.port ? ':' + location.port : '');
var url = full + '/admin/orders/edit/' + order.ID;
window.open(url, '_blank');
}
vm.editCustomer = function (order) {
var full = location.protocol + '//' + location.hostname + (location.port ? ':' + location.port : '');
var url = full + '/admin/customers/edit/' + order.CustomerID;
window.open(url, '_blank');
}
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
vm.subscriptionProduct.Description = $('#summernote').summernote('code');
if (vm.subscriptionProduct.CurrencyConversionTypeID > 0) {
setPrices();
}
else {
update();
}
};
vm.askDelete = function (item) {
var modalHtml = 'Are you sure you want to delete this?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
remove();
});
};
vm.goToSubscription = function () {
$location.path('/admin/subscriptions/edit/' + vm.subscriptionProduct.SubscriptionID);
};
function setPrices(result) {
bitcoinService.getBTCPrice(
getBTCPriceCompleted,
updateFailed,
true
);
}
function getBTCPriceCompleted(result) {
//get price by exchange
var data = result.data.data;
var priceByExchange = data.prices.filter(function (obj) {
return obj.exchange === vm.exchange;
});
//convert prices
var spotPrice = roundUp(priceByExchange[0].price, 0);
if (vm.subscriptionProduct.CurrencyConversionTypeID == 1) {
vm.subscriptionProduct.PriceFiat = $filter('btcToUsd')(vm.subscriptionProduct.Price, spotPrice);
}
else if (vm.subscriptionProduct.CurrencyConversionTypeID == 2) {
vm.subscriptionProduct.Price = $filter('usdToBtc')(vm.subscriptionProduct.PriceFiat, spotPrice);;
}
//update subscription product
update();
}
function loadOrders() {
apiService.get('/api/orders/subscriptionproduct/' + vm.subscriptionProduct.ID, null,
loadOrdersCompleted,
loadFailed);
}
function loadData() {
var url = '/api/subscriptionproducts/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function update() {
apiService.put('/api/subscriptionproducts/update', vm.subscriptionProduct,
updateSucceeded,
updateFailed);
}
function remove() {
var url = '/api/subscriptionproducts/delete';
apiService.post(url, vm.subscriptionProduct,
deleteSucceeded,
updateFailed
);
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully updated plan');
$scope.sForm.$setPristine();
vm.isLoading = true;
loadData();
}
function loadCompleted(result) {
vm.subscriptionProduct = result.data;
loadOrders();
}
function loadOrdersCompleted(result) {
vm.orders = result.data;
vm.totalRecords = vm.orders.length;
var tableParams = { page: 1, count: vm.orders.length, sorting: {} }
vm.ordersTable = new NgTableParams(tableParams, { counts: [], total: vm.orders.length, dataset: vm.orders });
vm.isLoading = false;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function deleteSucceeded(response) {
notificationService.displaySuccess('Successfully deleted rate');
$location.path('/admin/subscriptions/edit/' + vm.subscriptionProduct.Subscription.ID);
}
function updateFailed (response) {
notificationService.displayError(response.data.Message);
}
loadData();
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('addSubscriptionCtrl', addSubscriptionCtrl);
addSubscriptionCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$sce', 'apiService', 'notificationService', 'bitcoinService', 'fileUploadService'];
function addSubscriptionCtrl($scope, $rootScope, $routeParams, $location, $sce, apiService, notificationService, bitcoinService, fileUploadService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-add-subscription';
var vm = this;
vm.trust = $sce.trustAsHtml;
var itemImage = null;
vm.newRandom = Math.random();
vm.subscription = {
StatusId: 1,
CreatedDate: new Date(),
LastUpdated: new Date(),
subscriptionProduct: {
StatusId: 1,
IntervalID: 1,
SubscriptionID: $routeParams.id,
CreatedDate: new Date(),
LastUpdated: new Date()
}
};
vm.subscriptionStatus = [{ name: 'Enabled', id: 1 }, { name: 'Disabled', id: 2 }];
vm.subscriptionIntervals = [{ name: 'Daily', id: 1 }, { name: 'Weekly', id: 2 }, { name: 'Monthly', id: 3 }, { name: 'Quarterly', id: 4 }, { name: 'Annually', id: 5 }, { name: 'Bi-Annually', id: 6 }];
vm.productStatus = [{ name: 'Enabled', id: 1 }, { name: 'Disabled', id: 2 }];
vm.create = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
console.info(field);
angular.forEach(field, function (errorField) {
console.info(errorField);
errorField.$setDirty();
})
});
return;
}
vm.subscription.subscriptionProduct.Description = $('#summernote').summernote('code');
apiService.post('/api/subscriptions/add', vm.subscription,
createSucceded,
createFailed);
};
vm.prepareFiles = function ($files) {
itemImage = $files;
};
function createSucceded(response) {
notificationService.displaySuccess('Successfully added subscription');
vm.subscription = response.data;
sessionStorage.removeItem('/api/subscriptions');
if (itemImage) {
fileUploadService.uploadImage(itemImage, 'subscription', vm.subscription.ID, redirectToList);
}
else {
redirectToList();
}
}
function redirectToList() {
$location.path('/admin/subscriptions');
}
function createFailed (response) {
notificationService.displayError(response.data.Message);
}
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('editSubscriptionCtrl', editSubscriptionCtrl);
editSubscriptionCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', 'apiService', 'bitcoinService', 'NgTableParams', 'notificationService'];
function editSubscriptionCtrl($scope, $rootScope, $routeParams, $location, $modal, apiService, bitcoinService, NgTableParams, notificationService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-edit-subscription';
var vm = this;
var itemImage = null;
vm.isLoading = true;
vm.newRandom = Math.random();
vm.subscription = {};
vm.subscriptionStatus = [{ name: 'Enabled', id: 1 }, { name: 'Disabled', id: 2 }];
vm.subscriptionProductsTable = null;
vm.subscriptionProducts = [];
vm.totalCount = 0;
vm.closePage = function () {
var prevPage = window.location.href;
window.history.go(-1);
setTimeout(function () {
if (window.location.href == prevPage) {
window.close();
}
}, 500);
};
vm.edit = function (item) {
$location.path('/admin/subscriptions/products/edit/' + item.ID);
}
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
update();
};
vm.askDelete = function (item) {
var modalHtml = 'Are you sure you want to delete this?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
remove();
});
};
vm.prepareFiles = function ($files) {
itemImage = $files;
};
function loadSubscriptionProducts() {
var url = '/api/subscriptionproducts/subscription/' + vm.subscription.ID;
apiService.get(url, null,
loadSubscriptionProductsCompleted,
loadFailed
);
}
function loadSubscriptionProductsCompleted(result) {
vm.subscriptionProducts = result.data;
vm.totalCount = vm.subscriptionProducts.length;
vm.isLoading = false;
var tableParams = { page: 1, count: 10, sorting: {} }
vm.subscriptionProductsTable = new NgTableParams($scope.tableParams, { counts: [], total: vm.subscriptionProducts.length, dataset: vm.subscriptionProducts });
}
function loadData() {
var url = '/api/subscriptions/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function update() {
apiService.put('/api/subscriptions/update', vm.subscription,
updateSucceeded,
updateFailed);
}
function remove() {
var url = '/api/subscriptions/delete';
apiService.post(url, vm.subscription,
deleteSucceeded,
updateFailed
);
}
function loadCompleted(result) {
vm.subscription = result.data;
loadSubscriptionProducts();
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully updated subscription');
$scope.sForm.$setPristine();
sessionStorage.removeItem('/api/subscriptions/all');
vm.isLoading = true;
loadData();
}
function deleteSucceeded(response) {
notificationService.displaySuccess('Successfully deleted subscription');
$location.path('/admin/subscriptions');
}
function updateFailed (response) {
notificationService.displayError(response.data.Message);
}
loadData();
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('subscriptionsCtrl', subscriptionsCtrl);
subscriptionsCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', 'apiService', 'notificationService', 'NgTableParams'];
function subscriptionsCtrl($scope, $rootScope, $filter, $location, apiService, notificationService, NgTableParams) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-subscriptions';
var vm = this;
vm.subscriptionsTable = null;
vm.subscriptions = [];
vm.filter = "";
vm.statusId = "";
vm.page = 0;
vm.pageSize = 10;
vm.pagesCount = 0;
vm.totalCount = 0;
vm.edit = function (item) {
var fullPath = window.location.href + '/edit/' + item.ID;
window.open(fullPath, '_blank');
}
vm.pageChanged = function () {
search(vm.page - 1);
};
function search(page) {
page = page || 0;
var config = {
params: {
page: page,
pageSize: vm.pageSize,
filter: vm.filter,
statusId: vm.statusId
}
};
apiService.get('/api/subscriptions/', config,
loadCompleted,
loadFailed);
}
function loadCompleted(result) {
vm.subscriptions = result.data.Items;
vm.pagesCount = result.data.TotalPages;
vm.totalCount = result.data.TotalCount;
var tableParams = { page: 1, count: vm.pageSize, sorting: {name: 'asc'}}
vm.subscriptionsTable = new NgTableParams(tableParams, { counts: [], total: vm.totalCount, dataset: vm.subscriptions });
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
search(0);
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('addProductCtrl', addProductCtrl);
addProductCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$filter', 'apiService', 'notificationService', 'bitcoinService', 'fileUploadService'];
function addProductCtrl($scope, $rootScope, $routeParams, $location, $filter, apiService, notificationService, bitcoinService, fileUploadService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-add-product';
var vm = this;
var productImage = null;
var productFile = null;
vm.newRandom = Math.random();
vm.product = {
StatusId: 2,
CurrencyConversionTypeID: 0,
Date: new Date(),
CreatedDate: new Date(),
LastUpdated: new Date()
};
vm.productStatus = [{ name: 'Enabled', id: 1 }, { name: 'Disabled', id: 2 }];
vm.currencyConversionType = [{ name: 'Manual', id: 0 }, { name: 'Peg To BTC', id: 1 }, { name: 'Peg To USD', id: 2 }];
vm.exchange = "bitstamp";
vm.create = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
console.info(field);
angular.forEach(field, function (errorField) {
console.info(errorField);
errorField.$setDirty();
})
});
return;
}
if (vm.product.CurrencyConversionTypeID > 0) {
setPrices();
}
else {
apiService.post('/api/products/add', vm.product,
createSucceded,
createFailed);
}
};
vm.prepareImage = function ($files) {
productImage = $files;
};
vm.prepareFile = function ($files) {
productFile = $files;
};
vm.validatePaymentAddress = function () {
if (typeof vm.product.PaymentAddress != "undefined") {
$('#paymentAddress').addClass('input-loading');
bitcoinService.isAddressValid(
bitcoinServiceLoadCompleted,
createFailed
);
}
else return;
};
function setPrices(result) {
bitcoinService.getBTCPrice(
getBTCPriceCompleted,
createFailed,
true
);
}
function bitcoinServiceLoadCompleted(result) {
$('#paymentAddress').removeClass('input-loading');
if (result.data.is_valid) {
setPaymentAddressValid();
}
else {
setPaymentAddressInvalid();
}
}
function getBTCPriceCompleted(result) {
//get price by exchange
var spotPrice = roundUp(result.data, 0);
//convert prices
if (vm.product.CurrencyConversionTypeID == 1) {
vm.product.PriceFiat = $filter('btcToUsd')(vm.product.Price, spotPrice);
}
else if (vm.product.CurrencyConversionTypeID == 2) {
vm.product.Price = $filter('usdToBtc')(vm.product.PriceFiat, spotPrice);;
}
//add product
apiService.post('/api/products/add', vm.product,
createSucceded,
createFailed);
}
function createSucceded(response) {
notificationService.displaySuccess('Successfully added product');
vm.product = response.data;
sessionStorage.removeItem('/api/products');
if (productImage) {
fileUploadService.uploadImage(productImage, 'product', vm.product.ID, productImageCompleted);
}
else if (productFile) {
fileUploadService.uploadFile(productFile, 'product', vm.product.ID, redirectToList);
}
else {
redirectToList();
}
}
function productImageCompleted() {
if (productFile) fileUploadService.uploadFile(productFile, 'product', vm.product.ID, redirectToList);
else redirectToList();
}
function redirectToList() {
$location.path('/admin/products');
}
function createFailed(response) {
$('#paymentAddress').removeClass('input-loading');
notificationService.displayError(response.data.Message);
}
function setPaymentAddressValid() {
$('#paymentAddressFormGroup').addClass('has-error');
$scope.sForm.paymentAddress.$setValidity("valid", false);
}
function setPaymentAddressInvalid() {
$('#paymentAddressFormGroup').removeClass('has-error');
$('#paymentAddressFormGroup label.has-error').remove();
$scope.sForm.paymentAddress.$setValidity("valid", true);
}
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('editProductCtrl', editProductCtrl);
editProductCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', '$filter', '$http', 'apiService', 'bitcoinService', 'ordersService', 'NgTableParams', 'notificationService', 'fileUploadService'];
function editProductCtrl($scope, $rootScope, $routeParams, $location, $modal, $filter, $http, apiService, bitcoinService, ordersService, NgTableParams, notificationService, fileUploadService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-edit-product';
var productImage = null;
var productFile = null;
var vm = this;
vm.isLoading = true;
vm.newRandom = Math.random();
vm.product = {};
vm.orders = [];
vm.productStatus = [{ name: 'Enabled', id: 1 }, { name: 'Disabled', id: 2 }];
vm.currencyConversionType = [{ name: 'Manual', id: 0 }, { name: 'Peg To BTC', id: 1 }, { name: 'Peg To USD', id: 2 }];
vm.exchange = "bitstamp";
vm.page = 0;
vm.pageSize = 10;
vm.pagesCount = 0;
vm.totalCount = 0;
vm.edit = function (order) {
var full = location.protocol + '//' + location.hostname + (location.port ? ':' + location.port : '');
var url = full + '/admin/orders/edit/' + order.ID;
window.open(url, '_blank');
}
vm.editCustomer = function (order) {
var full = location.protocol + '//' + location.hostname + (location.port ? ':' + location.port : '');
var url = full + '/admin/customers/edit/' + order.CustomerID;
window.open(url, '_blank');
}
vm.pageChanged = function () {
search(vm.page);
};
vm.changePageSize = function () {
vm.page = 0;
search(0, true);
};
vm.closePage = function () {
var prevPage = window.location.href;
window.history.go(-1);
setTimeout(function () {
if (window.location.href == prevPage) {
window.close();
}
}, 500);
};
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
if (productImage) {
fileUploadService.uploadImage(productImage, 'product', vm.product.ID, productImageCompleted);
}
else if (productFile) {
fileUploadService.uploadFile(productFile, 'product', vm.product.ID, update);
}
else {
if (vm.product.CurrencyConversionTypeID > 0) {
setPrices();
}
else {
update();
}
}
};
vm.askDelete = function (item) {
var modalHtml = 'Are you sure you want to delete this?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
remove();
});
};
vm.prepareImage = function ($files) {
productImage = $files;
};
vm.prepareFile = function ($files) {
productFile = $files;
};
vm.download = function ($files) {
downloadFile();
};
function setPrices(result) {
bitcoinService.getBTCPrice(
getBTCPriceCompleted,
updateFailed,
true
);
}
function getBTCPriceCompleted(result) {
//get price by exchange
var data = result.data.data;
var priceByExchange = data.prices.filter(function (obj) {
return obj.exchange === vm.exchange;
});
//convert prices
var spotPrice = roundUp(priceByExchange[0].price, 0);
if (vm.product.CurrencyConversionTypeID == 1) {
vm.product.PriceFiat = $filter('btcToUsd')(vm.product.Price, spotPrice);
}
else if (vm.product.CurrencyConversionTypeID == 2) {
vm.product.Price = $filter('usdToBtc')(vm.product.PriceFiat, spotPrice);;
}
//update product
update();
}
function productImageCompleted() {
if (productFile) fileUploadService.uploadFile(productFile, 'product', vm.product.ID, update);
else update();
}
function downloadFile() {
var url = '/api/products/file/' + vm.product.ID
//window.open(url, '_blank', ''); //alternative method
$http({
method: 'GET',
url: url,
responseType: 'arraybuffer'
}).success(function (data, status, headers) {
headers = headers();
var filename = headers['x-filename'];
var contentType = headers['content-type'];
var linkElement = document.createElement('a');
try {
var blob = new Blob([data], { type: contentType });
var url = window.URL.createObjectURL(blob);
linkElement.setAttribute('href', url);
linkElement.setAttribute("download", filename);
var clickEvent = new MouseEvent("click", {
"view": window,
"bubbles": true,
"cancelable": false
});
linkElement.dispatchEvent(clickEvent);
//downloadFileCompleted();
} catch (ex) {
//downloadFileFailed(ex);
}
}).error(function (data) {
//downloadFileFailed(data);
});
}
function loadData() {
var url = '/api/products/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function update() {
apiService.put('/api/products/update', vm.product,
updateSucceeded,
updateFailed);
}
function remove() {
var url = '/api/products/delete';
apiService.post(url, vm.product,
deleteSucceeded,
updateFailed
);
}
function loadCompleted(result) {
vm.product = result.data;
vm.isLoading = false;
}
function search(page, reloadTable) {
if (reloadTable == true) {
vm.ordersTable.reload();
}
else {
vm.ordersTable.page(page);
}
}
vm.tableParams = { page: vm.page, count: vm.pageSize, sorting: {} }
vm.ordersTable = new NgTableParams(vm.tableParams, {
counts: [], total: vm.totalCount,
getData: function (params) {
var order = params.orderBy().toString();
var orderBy = order.charAt(1).toUpperCase().length > 0 ? order.charAt(1).toUpperCase() + order.slice(2) : "";
var orderByDirection = order.charAt(0) == "+" ? "asc" : "desc";
var config = {
params: {
page: vm.page == 0 ? vm.page : vm.page - 1,
pageSize: vm.pageSize,
orderBy: orderBy,
orderByDirection: orderByDirection,
productId: $routeParams.id,
}
};
return ordersService.getOrders(config).then(function (result) {
vm.orders = result.Items;
vm.pagesCount = result.TotalPages;
vm.totalCount = result.TotalCount;
vm.isLoading = false;
return vm.orders;
});
}
});
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully confirmed product');
$scope.sForm.$setPristine();
sessionStorage.removeItem('/api/products/public');
vm.isLoading = true;
loadData();
}
function deleteSucceeded(response) {
notificationService.displaySuccess('Successfully deleted product');
$location.path('/admin/products');
}
function updateFailed (response) {
notificationService.displayError(response.data.Message);
}
loadData();
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('productsCtrl', productsCtrl);
productsCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', 'apiService', 'notificationService', 'NgTableParams'];
function productsCtrl($scope, $rootScope, $filter, $location, apiService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-products';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.productsTable = null;
vm.products = [];
vm.filter = "";
vm.statusId = "";
vm.page = 0;
vm.pageSize = 10;
vm.pagesCount = 0;
vm.totalCount = 0;
vm.edit = function (product) {
var fullPath = window.location.href + '/edit/' + product.ID;
window.open(fullPath, '_blank');
//$location.path('/admin/products/edit/' + product.ID);
}
vm.pageChanged = function () {
search(vm.page - 1);
};
function search(page) {
page = page || 0;
var config = {
params: {
page: page,
pageSize: vm.pageSize,
filter: vm.filter,
statusId: vm.statusId
}
};
apiService.get('/api/products/', config,
loadCompleted,
loadFailed);
}
function loadCompleted(result) {
vm.products = result.data.Items;
vm.pagesCount = result.data.TotalPages;
vm.totalCount = result.data.TotalCount;
var tableParams = { page: 1, count: vm.pageSize, sorting: {name: 'asc'}}
vm.productsTable = new NgTableParams(tableParams, { counts: [], total: vm.totalCount, dataset: vm.products });
}
function loadFailed(response) {
notificationService.displayError(response.data);
}
function watch() {
$scope.$watch('[vm.filter, vm.statusId]', function (val) {
if (val != '' && val != undefined && val.length > 2) {
search();
} else {
search(0);
}
});
}
watch();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('addCategoryCtrl', addCategoryCtrl);
addCategoryCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$filter', '$sce', 'apiService', 'notificationService', 'bitcoinService', 'fileUploadService'];
function addCategoryCtrl($scope, $rootScope, $routeParams, $location, $filter, $sce, apiService, notificationService, bitcoinService, fileUploadService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-add-category';
var vm = this;
vm.trust = $sce.trustAsHtml;
vm.category = {
CreatedDate: new Date(),
LastUpdated: new Date()
};
vm.create = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
console.info(field);
angular.forEach(field, function (errorField) {
console.info(errorField);
errorField.$setDirty();
})
});
return;
}
vm.category.Description = $('#summernote').summernote('code');
apiService.post('/api/categories/add', vm.category,
createSucceded,
createFailed);
};
function createSucceded(response) {
notificationService.displaySuccess('Successfully added category');
vm.category = response.data;
sessionStorage.removeItem('/api/categories');
$location.path('/admin/categories');
}
function loadSummerNote() {
$(document).ready(function () {
setTimeout(function () {
$("#loadingSummerNote").hide();
$('#summernote').summernote({
toolbar: [
['style', ['bold', 'underline', 'italic', 'strikethrough']],
['para', ['ul', 'ol']],
['insert', ['video', 'link']],
['misc', ['undo', 'redo']],
['fullscreen', ['fullscreen', 'codeview', 'help']],
]
});
$('.note-btn').removeAttr('data-original-title');
}, 1000);
});
}
function createFailed(response) {
notificationService.displayError(response.data.Message);
}
loadSummerNote();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('editCategoryCtrl', editCategoryCtrl);
editCategoryCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', '$filter', '$http', '$sce', 'apiService', 'bitcoinService', 'ordersService', 'NgTableParams', 'notificationService', 'fileUploadService'];
function editCategoryCtrl($scope, $rootScope, $routeParams, $location, $modal, $filter, $http, $sce, apiService, bitcoinService, ordersService, NgTableParams, notificationService, fileUploadService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-edit-category';
var vm = this;
vm.trust = $sce.trustAsHtml;
vm.isLoading = true;
vm.category = {};
vm.pageChanged = function () {
search(vm.page);
};
vm.changePageSize = function () {
vm.page = 0;
search(0, true);
};
vm.closePage = function () {
var prevPage = window.location.href;
window.history.go(-1);
setTimeout(function () {
if (window.location.href == prevPage) {
window.close();
}
}, 500);
};
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
vm.category.Description = $('#summernote').summernote('code');
update();
};
vm.askDelete = function (item) {
var modalHtml = 'Are you sure you want to delete this?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
remove();
});
};
function loadData() {
var url = '/api/categories/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function update() {
apiService.put('/api/categories/update', vm.category,
updateSucceeded,
updateFailed);
}
function remove() {
var url = '/api/categories/delete';
apiService.post(url, vm.category,
deleteSucceeded,
updateFailed
);
}
function loadCompleted(result) {
vm.category = result.data;
loadSummerNote();
vm.isLoading = false;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully confirmed category');
$scope.sForm.$setPristine();
sessionStorage.removeItem('/api/categories/public');
vm.isLoading = true;
loadData();
}
function loadSummerNote() {
$(document).ready(function () {
setTimeout(function () {
$("#loadingSummerNote").hide();
$('#summernote').summernote({
toolbar: [
['style', ['bold', 'underline', 'italic', 'strikethrough']],
['para', ['ul', 'ol']],
['insert', ['video', 'link']],
['misc', ['undo', 'redo']],
['fullscreen', ['fullscreen', 'codeview', 'help']],
]
});
$('.note-btn').removeAttr('data-original-title');
}, 1000);
});
}
function deleteSucceeded(response) {
notificationService.displaySuccess('Successfully deleted category');
$location.path('/admin/categories');
}
function updateFailed (response) {
notificationService.displayError(response.data.Message);
}
loadData();
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('categoriesCtrl', categoriesCtrl);
categoriesCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', 'apiService', 'notificationService', 'NgTableParams'];
function categoriesCtrl($scope, $rootScope, $filter, $location, apiService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-categories';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.categoriesTable = null;
vm.categories = [];
vm.filter = "";
vm.statusId = "";
vm.page = 0;
vm.pageSize = 10;
vm.pagesCount = 0;
vm.totalCount = 0;
vm.edit = function (category) {
var fullPath = window.location.href + '/edit/' + category.ID;
window.open(fullPath, '_blank');
}
vm.pageChanged = function () {
search(vm.page - 1);
};
function search(page) {
page = page || 0;
var config = {
params: {
page: page,
pageSize: vm.pageSize,
filter: vm.filter
}
};
apiService.get('/api/categories/', config,
loadCompleted,
loadFailed);
}
function loadCompleted(result) {
vm.categories = result.data.Items;
vm.pagesCount = result.data.TotalPages;
vm.totalCount = result.data.TotalCount;
var tableParams = { page: 1, count: vm.pageSize, sorting: {name: 'asc'}}
vm.categoriesTable = new NgTableParams(tableParams, { counts: [], total: vm.totalCount, dataset: vm.categories });
}
function loadFailed(response) {
notificationService.displayError(response.data);
}
function watch() {
$scope.$watch('[vm.filter]', function (val) {
if (val != '' && val != undefined && val.length > 2) {
search();
} else {
search(0);
}
});
}
watch();
scrollToTop();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('addSeminarHelpCtrl', addSeminarHelpCtrl);
addSeminarHelpCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', 'apiService', 'notificationService'];
function addSeminarHelpCtrl($scope, $rootScope, $routeParams, $location, apiService, notificationService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-add-seminar-help';
var vm = this;
vm.loading = true;
vm.seminarHelp = {
CustomerID: "",
Contacted: false,
CreatedDate: new Date()
};
vm.customers = [];
vm.create = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
console.info(field);
angular.forEach(field, function (errorField) {
console.info(errorField);
errorField.$setDirty();
})
});
return;
}
apiService.post('/api/seminarhelp/add', vm.seminarHelp,
createSucceded,
createFailed);
};
function createSucceded(response) {
notificationService.displaySuccess('Successfully added seminar help');
vm.seminarHelp = response.data;
$location.path('/admin/seminarhelp');
}
function createFailed (response) {
notificationService.displayError(response.data.Message);
}
function loadCustomers() {
var url = '/api/customers/all';
vm.cacheKey = url;
apiService.get(url, null,
loadCustomersCompleted,
loadFailed
);
}
function loadCustomersCompleted(result) {
vm.customers = result.data;
vm.customers.push({ ID: "", FullName: 'Select Customer' });
vm.seminarHelp.CustomerID = "";
vm.loading = false;
}
function loadFailed(response) {
notificationService.displayError(response.data);
}
loadCustomers();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('editSeminarHelpCtrl', editSeminarHelpCtrl);
editSeminarHelpCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', 'apiService', 'NgTableParams', 'notificationService'];
function editSeminarHelpCtrl($scope, $rootScope, $routeParams, $location, $modal, apiService, NgTableParams, notificationService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-edit-seminar-help';
var vm = this;
vm.isLoading = true;
vm.seminarHelp = {};
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
update();
};
vm.setContacted = function (contacted) {
vm.seminarHelp.Contacted = contacted;
update();
};
vm.askDelete = function (item) {
var modalHtml = 'Are you sure you want to delete this?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
remove();
});
};
function loadData() {
vm.isLoading = true;
var url = '/api/seminarhelp/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function update() {
apiService.put('/api/seminarhelp/update', vm.seminarHelp,
updateSucceeded,
updateFailed);
}
function remove() {
var url = '/api/seminarhelp/delete';
apiService.post(url, vm.seminarHelp,
deleteSucceeded,
updateFailed
);
}
function loadCompleted(result) {
vm.isLoading = false;
vm.seminarHelp = result.data;
}
function loadFailed(response) {
vm.isLoading = false;
notificationService.displayError(response.data);
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully updated seminar help');
$scope.sForm.$setPristine();
loadData();
}
function deleteSucceeded(response) {
notificationService.displaySuccess('Successfully deleted seminar help');
$location.path('/admin/workshophelp');
}
function updateFailed (response) {
notificationService.displayError(response.data);
}
loadData();
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('adminSeminarHelpCtrl', adminSeminarHelpCtrl);
adminSeminarHelpCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', 'apiService', 'notificationService', 'NgTableParams'];
function adminSeminarHelpCtrl($scope, $rootScope, $filter, $location, apiService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-seminar-help';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.seminarHelpTable = null;
vm.seminarHelp = [];
vm.filter = "";
vm.isVenue = "";
vm.isCatering = "";
vm.isLodging = "";
vm.isMeetup = "";
vm.isOther = "";
vm.page = 0;
vm.pageSize = 10;
vm.pagesCount = 0;
vm.totalCount = 0;
vm.edit = function (seminarHelp) {
$location.path('/admin/workshophelp/edit/' + seminarHelp.ID);
}
vm.pageChanged = function () {
search(vm.page - 1);
};
function search(page) {
page = page || 0;
var config = {
params: {
page: page,
pageSize: vm.pageSize,
filter: vm.filter,
isVenue: vm.isVenue ? vm.isVenue : null,
isCatering: vm.isCatering ? vm.isCatering : null,
isLodging: vm.isLodging ? vm.isLodging : null,
isMeetup: vm.isMeetup ? vm.isMeetup : null,
isOther: vm.isOther ? vm.isOther : null,
}
};
apiService.get('/api/seminarhelp/', config,
loadCompleted,
loadFailed);
}
function loadCompleted(result) {
vm.seminarHelp = result.data.Items;
vm.pagesCount = result.data.TotalPages;
vm.totalCount = result.data.TotalCount;
var tableParams = { page: 1, count: vm.pageSize, sorting: {name: 'asc'}}
vm.seminarHelpTable = new NgTableParams(tableParams, { counts: [], total: vm.totalCount, dataset: vm.seminarHelp });
}
function loadFailed(response) {
notificationService.displayError(response.data);
}
function watch() {
$scope.$watch('[vm.filter, vm.isVenue, vm.isCatering, vm.isLodging, vm.isMeetup, vm.isOther]', function (val) {
if (val != '' && val != undefined && val.length > 2) {
search();
} else {
search(0);
}
});
}
watch();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('addOrderCtrl', addOrderCtrl);
addOrderCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', '$filter', 'apiService', 'NgTableParams', 'notificationService'];
function addOrderCtrl($scope, $rootScope, $routeParams, $location, $modal, $filter, apiService, NgTableParams, notificationService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-add-order';
var vm = this;
vm.isLoading = true;
vm.isError = false;
vm.errorMessage = "";
vm.customer = undefined;
vm.customers = [];
vm.seminars = [];
vm.allDiscounts = [];
vm.discounts = [];
vm.products = [];
vm.conferences = [];
vm.conferenceProducts = [];
vm.conferenceProductsByConferenceId = [];
vm.events = [];
vm.eventPrices = [];
vm.isWorkshop = false;
vm.isProduct = false;
vm.isConference = false;
vm.isEvent = false;
vm.formData = {
conferenceId: "0",
discountTypeId: "",
discountAmount: 0,
orderTypeId: 0
};
vm.order = {
StatusId: "",
InvoiceID: null,
Address: null,
TransactionID: null,
ConfirmID: null,
CustomerID: "",
SeminarID: "0",
ProductID: "0",
DiscountID: "0",
EventID: "0",
EventPriceID: "0",
DiscountAmount: 0,
TotalAmount: 0,
TotalDiscount: 0,
TotalPaid: 0,
Description: null,
PaymentAddressID: "",
PaidDate: null,
ConfirmedDate: null,
ConferenceProductID: "0",
CurrencyTypeID: 1,
CreatedDate: new Date()
};
vm.create = function (sForm) {
console.info('got here 1');
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
validateForm(sForm);
if (vm.order.CurrencyTypeID == 2) {
vm.order.PaymentAddressID = 1; //hack
console.info('set');
}
if (!vm.isError) {
create();
}
};
vm.selectCustomer = function ($item, $model, $label) {
vm.customer = $item;
vm.order.CustomerID = vm.customer.ID;
};
vm.selectOrderType = function (orderType) {
if (orderType == 'workshop') {
vm.formData.orderTypeId = 1;
vm.isProduct = false;
vm.isConference = false;
vm.isEvent = false;
vm.order.ProductID = "0";
vm.order.ConferenceProductID = "0";
vm.formData.conferenceId = "0";
vm.order.EventID = "0";
vm.order.EventPriceID = "0";
}
else if (orderType == 'product') {
vm.formData.orderTypeId = 2;
vm.isWorkshop = false;
vm.isConference = false;
vm.isEvent = false;
vm.order.SeminarID = "0";
vm.order.ConferenceProductID = "0";
vm.formData.conferenceId = "0";
vm.order.EventID = "0";
vm.order.EventPriceID = "0";
}
else if (orderType == 'conferece') {
vm.formData.orderTypeId = 3;
vm.isWorkshop = false;
vm.isProduct = false;
vm.isEvent = false;
vm.order.SeminarID = "0";
vm.order.ProductID = "0";
vm.order.EventID = "0";
vm.order.EventPriceID = "0";
}
else if (orderType == 'event') {
vm.formData.orderTypeId = 5;
vm.isWorkshop = false;
vm.isProduct = false;
vm.isConference = false;
vm.order.ConferenceProductID = "0";
vm.formData.conferenceId = "0";
vm.order.SeminarID = "0";
vm.order.ProductID = "0";
}
};
vm.loadConferenceProducts = function () {
//console.info(vm.formData.conferenceId);
vm.conferenceProductsByConferenceId = [];
var found = $filter('filter')(vm.conferences, { ID: vm.formData.conferenceId }, true);
if (found.length) {
vm.conferenceProductsByConferenceId = vm.conferenceProducts.filter(function (obj) {
return obj.ConferenceID === vm.formData.conferenceId;
});
vm.conferenceProductsByConferenceId.push({ ID: "0", TitleWithPrice: "Rates" });
}
};
vm.processAmount = function () {
vm.order.TotalAmount = 0;
if (vm.formData.orderTypeId == 1) {
var found = $filter('filter')(vm.seminars, { ID: vm.order.SeminarID }, true);
if (found.length) {
vm.order.TotalAmount = vm.order.CurrencyTypeID == 1 ? found[0].Price : found[0].PriceFiat;
vm.order.Description = found[0].Location;
}
}
else if (vm.formData.orderTypeId == 2) {
var found = $filter('filter')(vm.products, { ID: vm.order.ProductID }, true);
if (found.length) {
vm.order.TotalAmount = vm.order.CurrencyTypeID == 1 ? found[0].Price : found[0].PriceFiat;
vm.order.Description = found[0].Title;
}
}
else if (vm.formData.orderTypeId == 3) {
var found = $filter('filter')(vm.conferenceProducts, { ID: vm.order.ConferenceProductID }, true);
if (found.length) {
vm.order.TotalAmount = vm.order.CurrencyTypeID == 1 ? found[0].Price : found[0].PriceFiat;
vm.order.Description = found[0].Title;
}
}
else if (vm.formData.orderTypeId == 5) {
var found = $filter('filter')(vm.eventPrices, { ID: vm.order.EventPriceID }, true);
if (found.length) {
vm.order.TotalAmount = vm.order.CurrencyTypeID == 1 ? found[0].Price : found[0].PriceFiat;
vm.order.Description = found[0].Title;
}
}
vm.order.TotalPaid = vm.order.TotalAmount;
if (vm.order.StatusId == 2) {
vm.order.PaidDate = new Date();
}
else if (vm.order.StatusId == 3) {
vm.order.PaidDate = new Date();
vm.order.ConfirmedDate = new Date();
}
else {
vm.order.PaidDate = null;
vm.order.ConfirmedDate = null;
}
processDiscountList();
};
vm.processDiscount = function () {
vm.order.DiscountAmount = 0;
vm.order.TotalDiscount = 0;
vm.order.TotalPaid = vm.order.TotalAmount;
if (vm.formData.discountTypeId == '1') { // Manual
vm.order.DiscountAmount = parseFloat(vm.formData.discountAmount) / 100.0;
}
else if (vm.formData.discountTypeId == '2') { // From List
var found = $filter('filter')(vm.discounts, { ID: vm.order.DiscountID }, true);
if (found.length) {
vm.order.DiscountAmount = found[0].DiscountAmount;
}
}
vm.order.TotalDiscount = vm.order.TotalAmount * vm.order.DiscountAmount;
vm.order.TotalPaid = vm.order.TotalAmount - vm.order.TotalDiscount;
};
vm.clearDiscount = function () {
vm.order.DiscountAmount = 0;
vm.order.TotalDiscount = 0;
vm.order.TotalPaid = 0;
};
vm.clearTransaction = function () {
vm.order.TransactionID = null;
vm.order.Address = null;
vm.order.PaymentAddressID = "";
vm.order.SeminarID = "0";
vm.order.ProductID = "0";
vm.order.DiscountID = "0";
vm.order.EventID = "0";
vm.order.EventPriceID = "0";
vm.order.TotalAmount = 0;
vm.clearDiscount();
};
function validateForm(sForm) {
vm.isError = false;
console.info('got here 2');
//Check for tx info
if (vm.CurrencyTypeID == 1) {
if (vm.order.StatusId == 2 || vm.order.StatusId == 3) {
if (vm.order.TransactionID == null || vm.order.TransactionID == "") {
vm.errorMessage = "Transaction ID Required.";
vm.isError = true;
}
if (vm.order.PaymentAddressID == "" && (vm.order.Address == null || vm.order.Address == "")) {
vm.errorMessage = "Payment Address Required.";
vm.isError = true;
}
if (vm.order.PaymentAddressID != "" && (vm.order.Address != null && vm.order.Address != "")) {
vm.errorMessage = "Can't select both Custom and Existing Payment Addresses";
vm.isError = true;
}
if (vm.order.PaymentAddressID == 3) {
vm.order.Address = "generate";
vm.isError = true;
}
}
}
//Check for order type
if (vm.formData.orderTypeId == 0) {
vm.errorMessage = "Order Type Required.";
vm.isError = true;
}
//Check for workshop
else if (vm.formData.orderTypeId == 1 && vm.order.SeminarID == "0") {
vm.errorMessage = "Workshop Required.";
vm.isError = true;
}
//Check for product
else if (vm.formData.orderTypeId == 2 && vm.order.ProductID == "0") {
vm.errorMessage = "Product Required.";
vm.isError = true;
}
//Check for conference rate
else if (vm.formData.orderTypeId == 3 && vm.order.ConferenceProductID == "0") {
vm.errorMessage = "Conference Rate Required.";
vm.isError = true;
}
//Check for event and event price
else if (vm.formData.orderTypeId == 5 && (vm.order.EventID == "0" || vm.order.EventPriceID == "0")) {
vm.errorMessage = "Event and Price Required.";
vm.isError = true;
}
//Check for discount
if (vm.formData.discountTypeId == 1 && (vm.formData.discountAmount.length == 0 || vm.formData.discountAmount == 0)) {
vm.errorMessage = "Discount Amount Required.";
vm.isError = true;
}
else if (vm.formData.discountTypeId == 2 && vm.order.DiscountID == "0") {
vm.errorMessage = "Discount Required.";
vm.isError = true;
}
console.info(vm.errorMessage);
if (vm.isError) return;
}
function create() {
apiService.post('/api/orders/add', vm.order,
createSucceeded,
createFailed);
}
function createSucceeded() {
notificationService.displaySuccess('Successfully added order');
$location.path('/admin/orders');
}
function createFailed(response) {
notificationService.displayError(response.data.Message);
}
function loadCustomers() {
var url = '/api/customers/all';
apiService.get(url, null,
loadCustomersCompleted,
loadFailed
);
}
function loadSeminars() {
var url = '/api/seminars/all';
apiService.get(url, null,
loadSeminarsCompleted,
loadFailed
);
}
function loadProducts() {
var url = '/api/products/all';
apiService.get(url, null,
loadProductsCompleted,
loadFailed
);
}
function loadConferences() {
var url = '/api/conferences/all';
apiService.get(url, null,
loadConferencesCompleted,
loadFailed
);
}
function loadConferenceProducts() {
var url = '/api/conferenceproducts/all';
apiService.get(url, null,
loadConferenceProductsCompleted,
loadFailed
);
}
function loadEvents() {
var url = '/api/events/type/2';
apiService.get(url, null,
loadEventsCompleted,
loadFailed
);
}
function loadEventPrices() {
var url = '/api/eventprices/type/2';
apiService.get(url, null,
loadEventPricesCompleted,
loadFailed
);
}
function loadDiscounts() {
var url = '/api/discounts/all';
apiService.get(url, null,
loadDiscountsCompleted,
loadFailed
);
}
function processDiscountList() {
vm.discounts = [];
for (var i = 0; i < vm.allDiscounts.length; i++) {
var item = vm.allDiscounts[i];
if (item.OrderTypeID == vm.formData.orderTypeId && item.DiscountTypeID == 2) {
vm.discounts.push(item);
}
}
vm.discounts.push({ ID: "0", Title: 'Discounts' });
}
function loadCustomersCompleted(result) {
vm.customers = result.data;
loadSeminars();
loadProducts();
loadConferences();
loadConferenceProducts();
loadEvents();
loadEventPrices();
loadDiscounts();
}
function loadSeminarsCompleted(result) {
vm.seminars = result.data;
vm.seminars.push({ ID: "0", Location: 'Workshops' });
}
function loadProductsCompleted(result) {
vm.products = result.data;
vm.products.push({ ID: "0", Title: 'Products' });
}
function loadConferencesCompleted(result) {
vm.isLoading = false;
vm.conferences = result.data;
vm.conferences.push({ ID: "0", Title: 'Conferences' });
}
function loadConferenceProductsCompleted(result) {
vm.conferenceProducts = result.data;
}
function loadEventsCompleted(result) {
vm.events = result.data;
vm.events.push({ ID: "0", Title: 'Events' });
}
function loadEventPricesCompleted(result) {
vm.eventPrices = result.data;
vm.eventPrices.push({ ID: "0", TitleWithPrice: 'Event Prices' });
}
function loadDiscountsCompleted(result) {
vm.allDiscounts = result.data;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
loadCustomers();
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('editOrderCtrl', editOrderCtrl);
editOrderCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', '$sce', 'apiService', 'bitcoinService', 'NgTableParams', 'notificationService'];
function editOrderCtrl($scope, $rootScope, $routeParams, $location, $modal, $sce, apiService, bitcoinService, NgTableParams, notificationService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-edit-order';
var vm = this;
vm.hasHistory = false;
vm.trust = $sce.trustAsHtml;
vm.trustSrc = function (src) {
return $sce.trustAsResourceUrl(src);
}
vm.isLoading = true;
vm.isLoadingTransactions = false;
vm.orderData = {};
vm.transactions = [];
vm.seminars = [];
vm.seminarId = "0";
vm.formData = {
action: '',
transactionId: '',
discountAmount: '',
transactionId2: '',
paymentAddress: ''
};
vm.closePage = function () {
var prevPage = window.location.href;
window.history.go(-1);
setTimeout(function () {
if (window.location.href == prevPage) {
window.close();
}
}, 500);
};
vm.editSeminar = function () {
$location.path('/admin/workshops/edit/' + vm.orderData.Seminar.ID);
};
vm.editProduct = function () {
$location.path('/admin/products/edit/' + vm.orderData.Product.ID);
};
vm.editConference = function () {
$location.path('/admin/conferences/edit/' + vm.orderData.ConferenceProduct.ConferenceID);
};
vm.editSubscription = function () {
$location.path('/admin/subscriptions/edit/' + vm.orderData.SubscriptionProduct.SubscriptionID);
};
vm.editEvent = function () {
$location.path('/admin/events/edit/' + vm.orderData.Event.ID);
};
vm.setConfirmed = function () {
setConfirmed();
};
vm.setCanceled = function (isCanceled) {
setCanceled(isCanceled);
};
vm.setPaidAndConfirmed = function () {
setPaidAndConfirmed();
};
vm.resendRegistrationEmail = function () {
resendRegistrationEmail();
};
vm.sendConfirmEmail = function () {
sendConfirmEmail();
};
vm.resendConfirmEmail = function () {
resendConfirmEmail();
};
vm.resendFinalConfirmEmail = function () {
resendFinalConfirmEmail();
};
vm.updateOrderCurrency = function (currencyType) {
updateOrderCurrency(currencyType);
};
vm.updateOrderValidity = function (isValid) {
updateOrderValidity(isValid);
};
vm.updateOrderSeminar = function () {
updateOrderSeminar();
};
vm.emailSeminarStreamURL = function () {
emailSeminarStreamURL();
};
vm.emailSeminarPreStreamURL = function () {
emailSeminarPreStreamURL();
};
vm.completePayment = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
completePayment();
};
vm.addDiscount = function (sForm2) {
if (sForm2.$invalid) {
angular.forEach(sForm2.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
addDiscount();
};
vm.removeDiscount = function () {
removeDiscount();
};
vm.updatePaymentAddress = function (sForm3) {
if (sForm3.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
updatePaymentAddress();
};
vm.askDelete = function (item) {
var modalHtml = 'Are you sure you want to delete this?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
remove();
});
};
function emailSeminarPreStreamURL() {
apiService.put('/api/orders/email/seminarprestreamurl', vm.orderData.Order,
emailSeminarPreStreamURLSucceeded,
updateFailed);
}
function emailSeminarPreStreamURLSucceeded(response) {
notificationService.displaySuccess('Successfully sent meeting link to customer');
}
function emailSeminarStreamURL() {
apiService.put('/api/orders/email/seminarstreamurl', vm.orderData.Order,
emailSeminarStreamURLSucceeded,
updateFailed);
}
function emailSeminarStreamURLSucceeded(response) {
notificationService.displaySuccess('Successfully sent Youtube link to customer');
}
function sendConfirmEmail() {
apiService.put('/api/orders/email/seminarconfirmed', vm.orderData.Order,
emailSucceeded,
updateFailed);
}
function resendRegistrationEmail() {
apiService.put('/api/orders/email/registration', vm.orderData.Order,
emailSucceeded,
updateFailed);
}
function resendConfirmEmail() {
apiService.put('/api/orders/email/confirm', vm.orderData.Order,
emailSucceeded,
updateFailed);
}
function resendFinalConfirmEmail() {
apiService.put('/api/orders/email/finalconfirm', vm.orderData.Order,
emailSucceeded,
updateFailed);
}
function emailSucceeded(response) {
notificationService.displaySuccess('Successfully re-sent email');
}
function loadData() {
var url = '/api/orders/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function loadSeminars() {
var url = '/api/seminars/location/' + vm.orderData.Seminar.Location;
apiService.get(url, null,
loadSeminarsCompleted,
loadFailed
);
}
function loadSeminarsCompleted(result) {
vm.seminars = result.data;
vm.seminars.push({ ID: "0", LocationAndDate: 'Workshops' });
vm.isSeminarsLoaded = true;
}
function remove() {
var url = '/api/orders/delete';
apiService.post(url, vm.orderData.Order,
deleteSucceeded,
updateFailed
);
}
function updateOrderCurrency(currencyType) {
var orderCurrencyType = {
OrderID: vm.orderData.Order.ID,
CurrencyTypeID: currencyType
}
apiService.put('/api/orders/updatecurrency', orderCurrencyType,
updateSucceeded,
updateFailed);
}
function updateOrderSeminar(isValid) {
var order = {
OrderID: vm.orderData.Order.ID,
SeminarID: vm.seminarId
}
apiService.put('/api/orders/updateseminar', order,
updateSucceeded,
updateFailed);
}
function updateOrderValidity(isValid) {
var order = {
OrderID: vm.orderData.Order.ID,
IsValid: isValid
}
apiService.put('/api/orders/updatevalidity', order,
updateSucceeded,
updateFailed);
}
function setConfirmed() {
var orderConfirm = {
OrderID: vm.orderData.Order.ID,
StatusId: 3
}
apiService.put('/api/orders/confirm', orderConfirm,
confirmSucceeded,
updateFailed);
}
function setCanceled(isCanceled) {
var order = {
OrderID: vm.orderData.Order.ID,
IsValid: isCanceled
}
apiService.put('/api/orders/cancel', order,
updateSucceeded,
updateFailed);
}
function setPaidAndConfirmed() {
var payment = {
CustomerId: vm.orderData.CustomerID,
InvoiceId: vm.orderData.Order.InvoiceID,
TransactionId: vm.formData.transactionId
}
var url = '/api/orders/payandconfirm/';
apiService.put(url, payment,
setPaidAndConfirmedComplete,
loadFailed);
}
function setPaidAndConfirmedComplete(result) {
notificationService.displaySuccess('Successfully paid and confirmed order');
$scope.sForm.$setPristine();
vm.isLoading = true;
loadData();
}
function addDiscount() {
var payment = {
OrderID: vm.orderData.Order.ID,
DiscountAmount: parseFloat(vm.formData.discountAmount) / 100.0
}
var url = '/api/orders/applydiscount/';
apiService.put(url, payment,
addDiscountComplete,
loadFailed);
}
function addDiscountComplete(result) {
notificationService.displaySuccess('Successfully added discount');
$scope.sForm2.$setPristine();
vm.isLoading = true;
loadData();
}
function removeDiscount() {
var payment = {
OrderID: vm.orderData.Order.ID,
DiscountAmount: 0
}
var url = '/api/orders/removediscount/';
apiService.put(url, payment,
removeDiscountComplete,
loadFailed);
}
function removeDiscountComplete(result) {
notificationService.displaySuccess('Successfully removed discount');
$scope.sForm2.$setPristine();
vm.isLoading = true;
loadData();
}
function updatePaymentAddress() {
var orderUpdatePaymentAddress = {
Action: vm.formData.action,
OrderID: vm.orderData.Order.ID,
PaymentAddress: vm.formData.paymentAddress,
TransactionID: vm.formData.transactionId2
}
apiService.put('/api/orders/updatepaymentaddress', orderUpdatePaymentAddress,
updateSucceeded,
updateFailed);
}
function loadCompleted(result) {
if (typeof result.data != "undefined") {
vm.orderData = result.data;
//console.info(vm.orderData);
if (vm.orderData.Order.StatusId != 3 && vm.orderData.Order.StatusId != 6 && vm.orderData.Order.CurrencyTypeID == 1 && vm.orderData.Order.Address != null) {
getTransactionsReceived();
}
if (vm.orderData.OrderTypeID == 1 && vm.orderData.Seminar.IsOnline == false) {
loadSeminars();
}
}
else {
$location.path('/admin/orders');
}
vm.isLoading = false;
closeModals();
clearForms();
}
function closeModals() {
$('.modal').modal('hide');
}
function clearForms() {
$scope.sForm.$setPristine();
$scope.sForm2.$setPristine();
$scope.sForm3.$setPristine();
vm.formData.action = "";
vm.formData.transactionId = "";
vm.formData.discountAmount = "";
vm.formData.transactionId2 = "";
vm.formData.paymentAddress = "";
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function confirmSucceeded(response) {
notificationService.displaySuccess('Successfully confirmed order');
$scope.sForm.$setPristine();
vm.isLoading = true;
loadData();
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully updated order');
vm.isLoading = true;
loadData();
}
function deleteSucceeded(response) {
notificationService.displaySuccess('Successfully deleted order');
$location.path('/admin/orders');
}
function updateFailed (response) {
notificationService.displayError(response.data.Message);
}
function getTransactionsReceived() {
vm.isLoadingTransactions = true;
bitcoinService.getAddressTransactions(
vm.orderData.Order.Address,
getTransactionsReceivedCompleted,
getTransactionsReceivedsFailed,
true
);
}
function getTransactionsReceivedCompleted(result) {
vm.isLoadingTransactions = false;
vm.transactions = result.data.data.list;
}
function getTransactionsReceivedsFailed(response) {
//notificationService.displayError("Error finding transactions for this TransactionID");
}
loadData();
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('ordersCtrl', ordersCtrl);
ordersCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', '$q', '$http', 'apiService', 'ordersService', 'notificationService', 'NgTableParams'];
function ordersCtrl($scope, $rootScope, $filter, $location, $q, $http, apiService, ordersService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-orders';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.firstRun = true;
vm.ordersTable = null;
vm.orders = [];
vm.seminars = [];
vm.webinars = [];
vm.onDemand = [];
vm.isSeminarsLoaded = false;
vm.products = [];
vm.isProductsLoaded = false;
vm.conferences = [];
vm.conferenceProducts = [];
vm.isConferencesLoaded = false;
vm.subscriptions = [];
vm.subscriptionProducts = [];
vm.isSubscriptionsLoaded = false;
vm.eventPrices = [];
vm.isEventPricesLoaded = false;
vm.discounts = [];
vm.isDiscountsLoaded = false;
vm.pubKeys = [];
vm.pubKeysDropdown = [];
vm.filter = "";
vm.statusId = "";
vm.orderTypeId = "";
vm.currencyTypeId = "";
vm.seminarId = "0";
vm.productId = "0";
vm.conferenceId = "0";
vm.conferenceProductId = "0";
vm.subscriptionId = "0";
vm.subscriptionProductId = "0";
vm.eventPriceId = "0";
vm.discountId = "0";
vm.fromDate = "";
vm.toDate = "";
vm.pubKeyId = "0";
vm.page = 0;
vm.pageSize = 100;
vm.pagesCount = 0;
vm.totalCount = 0;
vm.orderBy = "";
vm.orderByDirection = "";
vm.datepicker = {};
vm.datepicker2 = {};
vm.dateOptions = {
formatYear: 'yy',
startingDay: 1,
showWeeks: false
};
vm.openDatePicker = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker.opened = true;
};
vm.openDatePicker2 = function ($event) {
$event.preventDefault();
$event.stopPropagation();
vm.datepicker2.opened = true;
};
vm.resendRegistrationEmailBatch = function () {
resendRegistrationEmailBatch();
};
vm.cancelPendingOrders = function () {
cancelPendingOrders();
};
vm.edit = function (order) {
//var fullPath = window.location.href + '/edit/' + order.ID;
var fullPath = window.location.href.replace('orders', 'customers') + '/edit/' + order.CustomerID;// + '#' + order.ID;
window.open(fullPath, '_blank');
//$location.path('/admin/orders/edit/' + order.ID);
}
vm.goToOrdersAdd = function() {
$location.path('/admin/orders/add');
};
vm.pageChanged = function () {
search(vm.page);
};
vm.changePageSize = function () {
vm.page = 0;
search(0, true);
};
vm.downloadFile = function () {
var url = '/api/orders/export';
var config = {
params: {
orderBy: vm.orderBy,
orderByDirection: vm.orderByDirection,
filter: vm.filter,
statusId: vm.statusId,
seminarId: vm.seminarId,
productId: vm.productId,
conferenceId: vm.conferenceId,
conferenceProductId: vm.conferenceProductId,
eventPriceId: vm.eventPriceId,
discountId: vm.discountId,
typeId: vm.orderTypeId,
currencyTypeId: vm.currencyTypeId,
fromDate: vm.fromDate,
toDate: vm.toDate,
pubKeyId: vm.pubKeyId
}
};
apiService.get(url, config,
downloadFileCompleted,
loadFailed
);
};
vm.loadOrderType = function () {
if (vm.orderTypeId == "") {
vm.seminarId = "0";
vm.productId = "0";
vm.conferenceId = "0";
vm.conferenceProductId = "0";
vm.subscriptionId = "0";
vm.subscriptionProductId = "0";
vm.eventPriceId = "0";
}
else if (vm.orderTypeId == 1 || vm.orderTypeId == 7 || vm.orderTypeId == 8) { //seminars/webinars/ondemand
vm.productId = "0";
vm.conferenceId = "0";
vm.conferenceProductId = "0";
vm.subscriptionId = "0";
vm.subscriptionProductId = "0";
vm.eventPriceId = "0";
if (!vm.isSeminarsLoaded) {
loadSeminars();
}
}
else if (vm.orderTypeId == 2) { //products
vm.seminarId = "0";
vm.conferenceId = "0";
vm.conferenceProductId = "0";
vm.eventPriceId = "0";
vm.subscriptionId = "0";
vm.subscriptionProductId = "0";
if (!vm.isProductsLoaded) {
loadProducts();
}
}
else if (vm.orderTypeId == 3) { //conferences
vm.seminarId = "0";
vm.productId = "0";
vm.eventPriceId = "0";
if (!vm.isConferencesLoaded) {
loadConferences();
}
}
else if (vm.orderTypeId == 5) { //event
vm.seminarId = "0";
vm.productId = "0";
vm.conferenceId = "0";
vm.conferenceProductId = "0";
vm.subscriptionId = "0";
vm.subscriptionProductId = "0";
if (!vm.isEventPricesLoaded) {
loadEventPrices();
}
}
else if (vm.orderTypeId == 6) { //subscriptions
vm.seminarId = "0";
vm.productId = "0";
vm.eventPriceId = "0";
vm.conferenceId = "0";
vm.conferenceProductId = "0";
if (!vm.isSubscriptionsLoaded) {
loadSubscriptions();
}
}
};
vm.loadDiscounts = function () {
if (!vm.isDiscountsLoaded) {
loadDiscounts();
}
};
vm.loadConferenceProducts = function () {
loadConferenceProducts();
};
vm.loadSubscriptionProducts = function () {
loadSubscriptionProducts();
};
vm.loadPubkeys = function () {
loadPubkeys();
};
function downloadFileCompleted(result) {
var data = result.data;
var url = location.protocol + '//' + location.hostname + (location.port ? ':' + location.port : '');
var fullPath = url + '/Content/temp/' + data.fileName;
window.open(fullPath);
}
function loadSeminars() {
var url = '/api/seminars/all/withorders';
apiService.get(url, null,
loadSeminarsCompleted,
loadFailed
);
}
function loadProducts() {
var url = '/api/products/all/withorders';
apiService.get(url, null,
loadProductsCompleted,
loadFailed
);
}
function loadConferences() {
var url = '/api/conferences/all';
apiService.get(url, null,
loadConferencesCompleted,
loadFailed
);
}
function loadConferenceProducts() {
var url = '/api/conferenceproducts/conference/' + vm.conferenceId;
apiService.get(url, null,
loadConferenceProductsCompleted,
loadFailed
);
}
function loadSubscriptions() {
var url = '/api/subscriptions/all';
apiService.get(url, null,
loadSubscriptionsCompleted,
loadFailed
);
}
function loadSubscriptionProducts() {
var url = '/api/subscriptionproducts/subscription/' + vm.subscriptionId;
apiService.get(url, null,
loadSubscriptionProductsCompleted,
loadFailed
);
}
function loadEventPrices() {
var url = '/api/eventprices/all';
apiService.get(url, null,
loadEventPricesCompleted,
loadFailed
);
}
function loadDiscounts() {
var url = '/api/discounts/all/withorders';
apiService.get(url, null,
loadDiscountsCompleted,
loadFailed
);
}
function search(page, reloadTable) {
if (reloadTable == true) {
vm.ordersTable.reload();
}
else {
vm.ordersTable.page(page);
}
}
vm.tableParams = { page: vm.page, count: vm.pageSize, sorting: {} }
vm.ordersTable = new NgTableParams(vm.tableParams, { counts: [], total: vm.totalCount,
getData: function (params) {
var order = params.orderBy().toString();
vm.orderBy = order.charAt(1).toUpperCase().length > 0 ? order.charAt(1).toUpperCase() + order.slice(2) : "";
vm.orderByDirection = order.charAt(0) == "+" ? "asc" : "desc";
var config = {
params: {
page: vm.page == 0 ? vm.page: vm.page - 1,
pageSize: vm.pageSize,
orderBy: vm.orderBy,
orderByDirection: vm.orderByDirection,
filter: vm.filter,
statusId: vm.statusId,
seminarId: vm.seminarId,
productId: vm.productId,
conferenceId: vm.conferenceId,
conferenceProductId: vm.conferenceProductId,
subscriptionId: vm.subscriptionId,
subscriptionProductId: vm.subscriptionProductId,
eventPriceId: vm.eventPriceId,
discountId: vm.discountId,
typeId: vm.orderTypeId,
currencyTypeId: vm.currencyTypeId,
fromDate: vm.fromDate,
toDate: vm.toDate,
pubKeyId: vm.pubKeyId
}
};
return ordersService.getOrders(config).then(function (result) {
vm.orders = result.Items;
vm.pagesCount = result.TotalPages;
vm.totalCount = result.TotalCount;
return vm.orders;
});
}
});
function loadSeminarsCompleted(result) {
var seminars = result.data;
vm.seminars = seminars.filter(function (obj) {
return obj.IsOnline == false && obj.IsOnDemand == false;
});
vm.webinars = seminars.filter(function (obj) {
return obj.IsOnline == true && obj.IsOnDemand == false;
});
vm.onDemand = seminars.filter(function (obj) {
return obj.IsOnline == false && obj.IsOnDemand == true;
});
vm.seminars.push({ ID: "0", LocationAndId: 'Workshops' });
vm.webinars.push({ ID: "0", LocationAndId: 'Webinars' });
vm.onDemand.push({ ID: "0", TitleAndId: 'OnDemand' });
vm.isSeminarsLoaded = true;
}
function loadProductsCompleted(result) {
vm.products = result.data;
vm.products.push({ ID: "0", Title: 'Products' });
vm.isProductsLoaded = true;
}
function loadConferencesCompleted(result) {
vm.conferences = result.data;
vm.conferences.push({ ID: "0", Title: 'Conferences' });
vm.isConferencesLoaded = true;
}
function loadConferenceProductsCompleted(result) {
vm.conferenceProducts = result.data;
vm.conferenceProducts.push({ ID: "0", Title: 'Conf Rates' });
}
function loadSubscriptionsCompleted(result) {
vm.subscriptions = result.data;
vm.subscriptions.push({ ID: "0", Title: 'Subscriptions' });
vm.isSubscriptionsLoaded = true;
}
function loadSubscriptionProductsCompleted(result) {
vm.subscriptionProducts = result.data;
vm.subscriptionProducts.push({ ID: "0", Title: 'Sub Plans' });
}
function loadEventPricesCompleted(result) {
vm.eventPrices = result.data;
vm.eventPrices.push({ ID: "0", Title: 'Event Prices' });
vm.isEventPricesLoaded = true;
}
function loadDiscountsCompleted(result) {
vm.discounts = result.data;
vm.discounts.push({ ID: "*", Title: 'From Database' });
vm.discounts.push({ ID: "Manual", Title: 'Manual' });
vm.discounts.push({ ID: "0", Title: 'Discounts' });
vm.isDiscountsLoaded = true;
}
function loadPubkeys() {
if (vm.currencyTypeId == 1) {
var url = '/api/pubkeys/all';
apiService.get(url, null,
loadPubkeysCompleted,
loadFailed
);
}
}
function loadPubkeysCompleted(result) {
vm.pubKeys = result.data;
if (vm.pubKeys.length > 0) {
angular.forEach(vm.pubKeys, function (item) {
var newItem = item;
if (newItem.Address.length > 50) newItem.Address = newItem.Address.substr(0, 50) + "...";
vm.pubKeysDropdown.push(newItem);
});
}
vm.pubKeysDropdown.push({ ID: "0", Title: "Pub Keys" });
vm.pubKeysDropdown.push({ ID: "all", Title: "Any" });
vm.pubKeysDropdown.push({ ID: "none", Title: "None" });
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
}
function resendRegistrationEmailBatch() {
apiService.put('/api/orders/email/registration/batch', null,
emailSucceeded,
updateFailed);
}
function emailSucceeded(response) {
notificationService.displaySuccess('Successfully sent registration emails');
}
function updateFailed(response) {
notificationService.displayError(response.data.Message);
}
function cancelPendingOrders() {
apiService.put('/api/orders/cancelpending', null,
cancelPendingOrdersSucceeded,
updateFailed);
}
function cancelPendingOrdersSucceeded(response) {
notificationService.displaySuccess('Successfully canceled pending orders');
watch();
}
function watch() {
$scope.$watch('[vm.filter, vm.statusId, vm.seminarId, vm.productId, vm.conferenceId, vm.conferenceProductId, vm.subscriptionId, vm.subscriptionProductId, vm.eventPriceId, vm.discountId, vm.orderTypeId, vm.currencyTypeId, vm.pubKeyId, vm.fromDate, vm.toDate]', function (val) {
if (!vm.firstRun) {
if (vm.filter != '' && vm.filter.length > 1) {
search(0, true);
}
else if (vm.filter == '') {
search(0, true);
}
else {
//do nothing
}
}
vm.firstRun = false;
});
}
watch();
//preload before user loads discounts from database
vm.discounts.push({ ID: "*", Title: 'From Database' });
vm.discounts.push({ ID: "Manual", Title: 'Manual' });
vm.discounts.push({ ID: "0", Title: 'Discounts' });
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('settingsCtrl', settingsCtrl);
settingsCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', 'apiService', 'notificationService', 'appConfig', 'fileUploadService'];
function settingsCtrl($scope, $rootScope, $filter, $location, apiService, notificationService, appConfig, fileUploadService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-settings';
var vm = this;
var qrImage = null;
vm.siteSettings = appConfig;
vm.showAlert = false;
vm.formData = {
key: "",
channelId: "",
qr: "",
address: "",
email: "",
host: "",
emailusername: "",
emailpassword: ""
};
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
var qrID = getQrId();
if (qrImage) {
fileUploadService.uploadDonationImage(qrImage, qrID, updateSiteSettingModel);
}
else
updateSiteSettingModel();
};
vm.prepareFiles = function ($files) {
qrImage = $files;
};
vm.hideAlert = function () {
vm.showAlert = false;
};
function getQrId() {
var id = null;
var found = $filter('filter')(vm.siteSettings, { SettingName: "qr" });
if (found.length) { id = found[0].ID; }
return id;
}
function updateSiteSettingModel(data) {
if (typeof data != 'undefined') {
vm.formData.qr = data.FileName;
vm.showAlert = true;
}
var SiteSetting = getFormData();
if (SiteSetting.SiteSettings.length > 0) {
apiService.post('/api/sitesettings/updatebatch', SiteSetting,
updateSucceded,
updateFailed);
}
else {
updateSucceded();
}
}
function updateSucceded(response) {
notificationService.displaySuccess('Successfully updated settings');
$scope.sForm.$setPristine();
app.constant("appConfig", vm.siteSettings);
sessionStorage.setItem("api/sitesettings", JSON.stringify(vm.siteSettings));
}
function updateFailed(response) {
notificationService.displayError(response);
}
function setFormData() {
{
var found = $filter('filter')(vm.siteSettings, { SettingName: "key" });
if (found.length) { vm.formData.key = found[0].SettingVar; }
}
{
var found = $filter('filter')(vm.siteSettings, { SettingName: "channelId" });
if (found.length) { vm.formData.channelId = found[0].SettingVar; }
}
{
var found = $filter('filter')(vm.siteSettings, { SettingName: "qr" });
if (found.length) { vm.formData.qr = found[0].SettingVar; }
}
{
var found = $filter('filter')(vm.siteSettings, { SettingName: "address" });
if (found.length) { vm.formData.address = found[0].SettingVar; }
}
{
var found = $filter('filter')(vm.siteSettings, { SettingName: "email" });
if (found.length) { vm.formData.email = found[0].SettingVar; }
}
{
var found = $filter('filter')(vm.siteSettings, { SettingName: "host" });
if (found.length) { vm.formData.host = found[0].SettingVar; }
}
{
var found = $filter('filter')(vm.siteSettings, { SettingName: "emailusername" });
if (found.length) { vm.formData.emailusername = found[0].SettingVar; }
}
{
var found = $filter('filter')(vm.siteSettings, { SettingName: "emailpassword" });
if (found.length) { vm.formData.emailpassword = found[0].SettingVar; }
}
}
function getFormData() {
var string = JSON.stringify(vm.siteSettings);
var originalSiteSettings = JSON.parse(string);
var newSiteSettings = [];
//set local vars
for (var i = 0; i < vm.siteSettings.length; i++) {
var prop = vm.siteSettings[i];
if (prop.SettingName == "key") vm.siteSettings[i].SettingVar = vm.formData.key;
else if (prop.SettingName == "channelId") vm.siteSettings[i].SettingVar = vm.formData.channelId;
else if (prop.SettingName == "qr") vm.siteSettings[i].SettingVar = vm.formData.qr;
else if (prop.SettingName == "address") vm.siteSettings[i].SettingVar = vm.formData.address;
else if (prop.SettingName == "email") vm.siteSettings[i].SettingVar = vm.formData.email;
else if (prop.SettingName == "host") vm.siteSettings[i].SettingVar = vm.formData.host;
else if (prop.SettingName == "emailusername") vm.siteSettings[i].SettingVar = vm.formData.emailusername;
else if (prop.SettingName == "emailpassword") vm.siteSettings[i].SettingVar = vm.formData.emailpassword;
}
//only update db with changed vars
for (var i = 0; i < originalSiteSettings.length; i++) {
var originalProp = originalSiteSettings[i];
var newProp = vm.siteSettings[i];
if (originalProp.SettingName != "qr") {
if (originalProp.SettingVar != newProp.SettingVar) {
newSiteSettings.push(newProp);
}
}
}
var SiteSetting = {
ID: 0,
LastUpdated: null,
SettingName: null,
SettingVar: null,
SettingsTypeId: 0,
SiteSettings: newSiteSettings
};
return SiteSetting;
}
setFormData();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('pagesCtrl', pagesCtrl);
pagesCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', 'apiService', 'notificationService', 'NgTableParams'];
function pagesCtrl($scope, $rootScope, $filter, $location, apiService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-pages';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.pageContentTable = null;
vm.pageContent = [];
vm.isLoading = true;
vm.totalRecords = 0;
vm.edit = function (page) {
$location.path('/admin/pages/edit/' + page.ID);
}
function loadData() {
var url = '/api/pagecontent';
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function loadCompleted(result) {
vm.pageContent = result.data;
vm.totalRecords = vm.pageContent.length;
vm.isLoading = false;
var tableParams = { page: 1, count: 100, sorting: {}}
vm.pageContentTable = new NgTableParams(tableParams, { counts: [], total: vm.pageContent.length, dataset: vm.pageContent });
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
loadData();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('editPageCtrl', editPageCtrl);
editPageCtrl.$inject = ['$scope', '$rootScope', '$routeParams', 'apiService', 'notificationService', '$sce'];
function editPageCtrl($scope, $rootScope, $routeParams, apiService, notificationService, $sce) {
$scope.pageClass = 'page-admin-edit-page';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.isLoading = true;
vm.page = {};
vm.trust = $sce.trustAsHtml;
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
vm.page.Content = $('#summernote').summernote('code');
apiService.put('/api/pagecontent/update', vm.page,
updateSucceded,
updateFailed);
};
function loadData() {
var url = '/api/pagecontent/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function loadCompleted(result) {
vm.page = result.data;
loadSummerNote();
vm.isLoading = false;
}
function loadSummerNote() {
$(document).ready(function () {
setTimeout(function () {
$("#loadingSummerNote").hide();
$('#summernote').summernote({
fontSizes: ['8', '9', '10', '11', '12', '14', '16', '18', '24', '36', '48'],
toolbar: [
['header', ['style']],
['style', ['bold', 'underline', 'italic', 'strikethrough']],
['font', ['fontsize', 'color']],
['para', ['ul', 'ol', 'paragraph']],
['table', ['table']],
['insert', ['imageButton', 'video', 'link']],
['misc', ['undo', 'redo']],
['fullscreen', ['fullscreen', 'codeview', 'help']],
],
buttons: {
imageButton: ImageButton
}
});
$('.note-btn').removeAttr('data-original-title');
$('.note-editor a').click(function () {
window.open(this.href);
return false; });
}, 1000);
});
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function updateSucceded(response) {
notificationService.displaySuccess('Successfully updated page');
$scope.sForm.$setPristine();
sessionStorage.removeItem('/api/pagecontent');
$scope.$emit("forcePageContentLoad");
}
function updateFailed (response) {
notificationService.displayError(response);
}
loadData();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('mediaContentCtrl', mediaContentCtrl);
mediaContentCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', '$modal', 'apiService', 'notificationService', 'NgTableParams'];
function mediaContentCtrl($scope, $rootScope, $filter, $location, $modal, apiService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-emails';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.mediaContentTable = null;
vm.mediaContent = [];
vm.isLoading = true;
vm.totalRecords = 0;
vm.askDelete = function (item) {
var modalHtml = 'Are you sure you want to delete this?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
remove(item);
});
};
function remove(item) {
var url = '/api/mediacontent/delete';
apiService.post(url, item,
deleteSucceeded,
updateFailed
);
}
function deleteSucceeded(response) {
loadData();
notificationService.displaySuccess('Successfully deleted image');
}
function updateFailed(response) {
notificationService.displayError(response.data.Message);
}
function loadData() {
var url = '/api/mediacontent';
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function loadCompleted(result) {
vm.mediaContent = result.data;
vm.totalRecords = vm.mediaContent.length;
vm.isLoading = false;
var tableParams = { page: 1, count: 30, sorting: {}}
vm.mediaContentTable = new NgTableParams(tableParams, { counts: [], total: vm.mediaContent.length, dataset: vm.mediaContent });
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
loadData();
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('addMediaContentCtrl', addMediaContentCtrl);
addMediaContentCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', 'apiService', 'NgTableParams', 'fileUploadService', 'notificationService'];
function addMediaContentCtrl($scope, $rootScope, $routeParams, $location, $modal, apiService, NgTableParams, fileUploadService, notificationService) {
$scope.pageClass = 'page-admin-add-media-content';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.mediaImage = null;
vm.mediaContent = {
MediaTypeID: 1,
CreatedDate: new Date(),
};
vm.prepareFiles = function ($files) {
vm.mediaImage = $files;
};
vm.create = function (sForm) {
fileUploadService.uploadMediaContentImageImage(vm.mediaImage, createSucceded);
};
function createSucceded(response) {
notificationService.displaySuccess('Successfully added media content');
$location.path('/admin/media');
}
function createFailed(response) {
notificationService.displayError(response.data.Message);
}
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('emailsCtrl', emailsCtrl);
emailsCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', 'apiService', 'notificationService', 'NgTableParams'];
function emailsCtrl($scope, $rootScope, $filter, $location, apiService, notificationService, NgTableParams) {
$scope.pageClass = 'page-admin-emails';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.emailContentTable = null;
vm.emails = [];
vm.isLoading = true;
vm.totalRecords = 0;
vm.edit = function (email) {
$location.path('/admin/emails/edit/' + email.ID);
}
function loadData() {
var url = '/api/emails/type/1';
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function loadCompleted(result) {
vm.emails = result.data;
vm.totalRecords = vm.emails.length;
vm.isLoading = false;
modifyList();
var tableParams = { page: 1, count: vm.emails.length, sorting: {}}
vm.emailContentTable = new NgTableParams(tableParams, { counts: [], total: vm.emails.length, dataset: vm.emails });
}
function modifyList() {
angular.forEach(vm.emails, function (email) {
if (email.Title.indexOf('Workshop') > -1) {
if (email.Title.indexOf('OnDemand') > -1) email.EmailType = 'OnDemand';
else if (email.Title.indexOf('Online') > -1 || email.Description.indexOf('Webinar') > -1) email.EmailType = 'Webinar';
else email.EmailType = 'Workshop';
}
if (email.Title.indexOf('Product') > -1) email.EmailType = 'Product';
if (email.Title.indexOf('Conference') > -1) email.EmailType = 'Conference';
if (email.Title.indexOf('Video') > -1) email.EmailType = 'Video';
if (email.Title.indexOf('Event') > -1) email.EmailType = 'Event';
if (email.Title.indexOf('Telegram') > -1) email.EmailType = 'Telegram';
if (email.Title.indexOf('Order') > -1) email.EmailType = 'Order';
if (email.Title.indexOf('Coupon') > -1) email.EmailType = 'Coupon';
if (email.Title.indexOf('Account') > -1) email.EmailType = 'Account';
if (email.Title.indexOf('Subscription') > -1) email.EmailType = 'Subscription';
});
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
loadData();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('editEmailCtrl', editEmailCtrl);
editEmailCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', '$sce', 'apiService', 'notificationService'];
function editEmailCtrl($scope, $rootScope, $routeParams, $location, $modal, $sce, apiService, notificationService) {
$scope.pageClass = 'page-admin-edit-email';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.isLoading = true;
vm.email = {};
vm.trust = $sce.trustAsHtml;
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
vm.email.Body = $('#summernote').summernote('code');
apiService.put('/api/emails/update', vm.email,
updateSucceeded,
updateFailed);
};
vm.sendTest = function () {
apiService.put('/api/emails/sendtest', vm.email,
emailSucceeded,
updateFailed);
};
vm.askDelete = function (item) {
var modalHtml = 'Are you sure you want to delete this?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
remove();
});
};
function loadData() {
var url = '/api/emails/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function remove() {
var url = '/api/emails/delete';
apiService.post(url, vm.email,
deleteSucceeded,
updateFailed
);
}
function emailSucceeded(response) {
notificationService.displaySuccess('Successfully sent email');
}
function loadCompleted(result) {
vm.email = result.data;
loadSummerNote();
vm.isLoading = false;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function deleteSucceeded(response) {
notificationService.displaySuccess('Successfully deleted automated email');
$location.path('/admin/emails');
}
function loadSummerNote() {
$(document).ready(function () {
setTimeout(function () {
$("#loadingSummerNote").hide();
$('#summernote').summernote({
fontSizes: ['8', '9', '10', '11', '12', '14', '16', '18', '24', '36', '48'],
toolbar: [
['header', ['style']],
['style', ['bold', 'underline', 'italic', 'strikethrough']],
['font', ['fontsize', 'color']],
['para', ['ul', 'ol', 'paragraph']],
['table', ['table']],
['insert', ['imageButton', 'video', 'link']],
['misc', ['undo', 'redo']],
['fullscreen', ['fullscreen', 'codeview', 'help']],
],
buttons: {
imageButton: ImageButton
}
});
$('.note-btn').removeAttr('data-original-title');
}, 1000);
});
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully updated email');
$scope.sForm.$setPristine();
}
function updateFailed (response) {
notificationService.displayError(response);
}
loadData();
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('usersAdminCtrl', usersAdminCtrl);
usersAdminCtrl.$inject = ['$scope', '$rootScope', '$filter', '$location', 'apiService', 'notificationService', 'NgTableParams'];
function usersAdminCtrl($scope, $rootScope, $filter, $location, apiService, notificationService, NgTableParams) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-users';
var vm = this;
vm.usersTable = null;
vm.users = [];
vm.isLoading = true;
vm.totalRecords = 0;
vm.edit = function (user) {
$location.path('/admin/users/edit/' + user.ID);
}
function loadData() {
var url = '/api/account/admins';
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function loadCompleted(result) {
vm.users = result.data;
//hide customer account as the system needs this for users to checkout
vm.users = vm.users.filter(function (obj) {
return obj.Username !== 'customer';
});
vm.totalRecords = vm.users.length;
vm.isLoading = false;
var tableParams = { page: 1, count: 10, sorting: {} }
vm.usersTable = new NgTableParams($scope.tableParams, { counts: [], total: vm.users.length, dataset: vm.users });
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
loadData();
}
})(angular.module('app'));;
(function (app) {
'use strict';
app.controller('editUserCtrl', editUserCtrl);
editUserCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', 'apiService', 'membershipService', 'notificationService'];
function editUserCtrl($scope, $rootScope, $routeParams, $location, $modal, apiService, membershipService, notificationService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-edit-user';
var vm = this;
vm.isLoading = true;
vm.user = {};
vm.roles = [];
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
update();
};
vm.lockUser = function (sForm) {
vm.user.IsLocked = true;
};
vm.unlockUser = function (sForm) {
vm.user.IsLocked = false;
};
vm.askDelete = function (item) {
if ($rootScope.repository.loggedUser.username == vm.user.Username) {
notificationService.displayError("You can't delete your own account");
}
else {
var modalHtml = 'Are you sure you want to delete this?
';
modalHtml += '';
var modalInstance = $modal.open({
template: modalHtml,
controller: ModalInstanceCtrl,
controllerAs: 'vm'
});
modalInstance.result.then(function () {
remove();
});
}
};
vm.showWarning = false;
function loadData() {
var url = '/api/account/' + $routeParams.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function loadRoles() {
var url = '/api/account/roles';
apiService.get(url, null,
loadRolesCompleted,
loadFailed
);
}
function remove() {
membershipService.remove(vm.user, deleteSucceded, updateFailed);
}
function update() {
var user = {
id: vm.user.ID,
username: vm.user.Username,
password: vm.user.Password
};
if (typeof vm.user.Password != "undefined" && vm.user.Password != "") {
//TODO: check to make sure prev pssword works
membershipService.updatePasswordById(user, resetSucceeded, resetFailed);
}
if (vm.roleId != vm.user.RoleId) {
vm.user.RoleId = vm.roleId;
membershipService.updateRole(vm.user, updateSucceeded, updateFailed);
}
membershipService.update(vm.user, updateSucceeded, updateFailed);
if (vm.user.ID == $rootScope.repository.loggedUser.id) {
//seems to only work when you change your password, but if you change your username you become un-authenticated and have to re-login
membershipService.saveCredentials(user);
}
}
function loadCompleted(result) {
if (typeof result.data != "undefined") {
vm.user = result.data;
vm.roleId = vm.user.RoleId;
vm.showWarning = (vm.user.ID == $rootScope.repository.loggedUser.id);
}
else {
$location.path('/admin/users');
}
vm.isLoading = false;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function loadRolesCompleted(result) {
vm.roles = result.data.roles;
vm.roles = vm.roles.filter(function (obj) {
return obj.Name !== 'Customer';
});
vm.isLoading = false;
}
function resetFailed(response) {
notificationService.displayError(response.data.Message);
}
function resetSucceeded(response) {
notificationService.displaySuccess('Successfully updated password');
vm.user.Password = "";
$scope.sForm.$setPristine();
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully updated user');
$scope.sForm.$setPristine();
}
function deleteSucceded(response) {
notificationService.displaySuccess('Successfully deleted user');
$location.path('/admin/users');
}
function updateFailed (response) {
notificationService.displayError(response.data.Message);
}
loadRoles();
loadData();
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('editAccountCtrl', editAccountCtrl);
editAccountCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', '$modal', 'apiService', 'membershipService', 'notificationService'];
function editAccountCtrl($scope, $rootScope, $routeParams, $location, $modal, apiService, membershipService, notificationService) {
$scope.pageClass = 'page-admin-edit-account';
$rootScope.$broadcast("updatePageLocation", "admin");
var vm = this;
vm.isLoading = true;
vm.user = {};
vm.update = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
update();
};
function loadData() {
var url = '/api/account/' + $rootScope.repository.loggedUser.id;
apiService.get(url, null,
loadCompleted,
loadFailed
);
}
function update() {
if (typeof vm.user.Password == "undefined" || vm.user.Password == "") {
membershipService.update(vm.user, updateSucceeded, updateFailed);
}
else {
var user = {
id: $rootScope.repository.loggedUser.id,
username: vm.user.Username,
password: vm.user.Password
};
membershipService.updatePassword(user, resetSucceeded, resetFailed);
membershipService.update(vm.user, updateSucceeded, updateFailed);
membershipService.saveCredentials(user); //seems to only work when you change your password, but if you change your username you become un-authenticated and have to re-login
}
}
function loadCompleted(result) {
if (typeof result.data != "undefined") {
vm.user = result.data;
}
else {
$location.path('/admin');
}
vm.isLoading = false;
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function resetFailed(response) {
notificationService.displayError(response.data.Message);
}
function resetSucceeded(response) {
notificationService.displaySuccess('Successfully updated password');
vm.user.Password = "";
$scope.sForm.$setPristine();
}
function updateSucceeded(response) {
notificationService.displaySuccess('Successfully updated user');
$scope.sForm.$setPristine();
}
function updateFailed (response) {
notificationService.displayError(response.data.Message);
}
loadData();
}
ModalInstanceCtrl.$inject = ['$scope', '$modalInstance'];
function ModalInstanceCtrl($scope, $modalInstance) {
var vm = this;
vm.ok = function () {
$modalInstance.close();
};
vm.cancel = function () {
$modalInstance.dismiss('cancel');
};
}
})(angular.module('app'));
;
(function (app) {
'use strict';
app.controller('addUserCtrl', addUserCtrl);
addUserCtrl.$inject = ['$scope', '$rootScope', '$routeParams', '$location', 'apiService', 'membershipService', 'notificationService'];
function addUserCtrl($scope, $rootScope, $routeParams, $location, apiService, membershipService, notificationService) {
$rootScope.$broadcast("updatePageLocation", "admin");
$scope.pageClass = 'page-admin-add-user';
var vm = this;
vm.isLoading = true;
vm.roles = [];
vm.user = {
FirstName: '',
LastName: '',
RoleId: 1,
Username: '',
Email: '',
Password: ''
};
vm.create = function (sForm) {
if (sForm.$invalid) {
angular.forEach(sForm.$error, function (field) {
angular.forEach(field, function (errorField) {
errorField.$setDirty();
})
});
return;
}
create();
}
function loadRoles() {
var url = '/api/account/roles';
apiService.get(url, null,
loadRolesCompleted,
loadFailed
);
}
function loadFailed(response) {
notificationService.displayError(response.data.Message);
vm.isLoading = false;
}
function loadRolesCompleted(result) {
vm.roles = result.data.roles;
vm.roles = vm.roles.filter(function (obj) {
return obj.Name !== 'Customer';
});
vm.isLoading = false;
}
function create() {
membershipService.register(vm.user, createSucceded, createFailed);
}
function createSucceded(response) {
notificationService.displaySuccess('Successfully added user');
$location.path('/admin/users');
}
function createFailed(response) {
notificationService.displayError(response.data.Message);
}
//remove form auto fill from browser
setTimeout(function () { $('form input').val(""); }, 200);
loadRoles();
}
})(angular.module('app'));;