https://mnwebfest.com/_modules/mnwf/util/enumerations.js

1import {Enum} from "../../imaginary/util/enumeration.js";
2import {AgreementType} from "../../sparq/util/enums.js";
3
4
5export class BannerStyle extends Enum {
6    static get Wide() { return Enum.forKey(BannerStyle, 'Wide'); };
7    static get HD() { return Enum.forKey(BannerStyle, 'HD'); };
8    static get Square() { return Enum.forKey(BannerStyle, 'Square'); };
9
10    static get all() {
11        return Enum.instances(BannerStyle);
12    }
13
14    static bannerStyle(code) {
15        if( isNaN(code) ) {
16            return Enum.forKey(BannerStyle, code);
17        }
18        return Enum.forCode(BannerStyle, code);
19    }
20
21    toString() {
22        return this.name;
23    }
24}
25
26Enum.register(BannerStyle, 'Wide', 1);
27Enum.register(BannerStyle, 'HD', 2);
28Enum.register(BannerStyle, 'Square', 3);
29
30
31export class EventStyle extends Enum {
32    static get InPerson() { return Enum.forKey(EventStyle, 'InPerson'); };
33    static get Online() { return Enum.forKey(EventStyle, 'Online'); };
34    static get Simulcast() { return Enum.forKey(EventStyle, 'Simulcast'); };
35    static get Hybrid() { return Enum.forKey(EventStyle, 'Hybrid'); };
36
37    static get all() {
38        return Enum.instances(EventStyle);
39    }
40
41    static eventStyle(code) {
42        if( isNaN(code) ) {
43            return Enum.forKey(EventStyle, code);
44        }
45        return Enum.forCode(EventStyle, code);
46    }
47
48    get inPerson() {
49        return !this.equals(EventStyle.Online)
50    }
51
52    get online() {
53        return !this.equals(EventStyle.InPerson);
54    }
55
56    toString() {
57        return this.name;
58    }
59}
60
61Enum.register(EventStyle, 'InPerson', 1);
62Enum.register(EventStyle, 'Online', 2);
63Enum.register(EventStyle, 'Simulcast', 3);
64Enum.register(EventStyle, 'Hybrid', 4);
65
66
67export class EventType extends Enum {
68    static get Networking() { return Enum.forKey(EventType, 'Networking'); };
69    static get Screening() { return Enum.forKey(EventType, 'Screening'); };
70    static get Keynote() { return Enum.forKey(EventType, 'Keynote'); };
71    static get Presentation() { return Enum.forKey(EventType, 'Presentation'); };
72    static get Panel() { return Enum.forKey(EventType, 'Panel'); };
73    static get Workshop() { return Enum.forKey(EventType, 'Workshop'); };
74    static get AwardsCeremony() { return Enum.forKey(EventType, 'AwardsCeremony'); };
75    static get TableRead() { return Enum.forKey(EventType, 'TableRead'); };
76    static get Pitch() { return Enum.forKey(EventType, 'Pitch'); };
77    static get Other() { return Enum.forKey(EventType, 'Other'); };
78
79    static get all() {
80        return Enum.instances(EventType);
81    }
82
83    static eventType(code) {
84        if( isNaN(code) ) {
85            return Enum.forKey(EventType, code);
86        }
87        return Enum.forCode(EventType, code);
88    }
89
90    toString() {
91        return this.name;
92    }
93}
94
95Enum.register(EventType, 'Networking', 1, 'programming');
96Enum.register(EventType, 'Screening', 2, 'programming');
97Enum.register(EventType, 'Keynote', 3, 'programming');
98Enum.register(EventType, 'Presentation', 4, 'programming');
99Enum.register(EventType, 'Panel', 5, 'programming');
100Enum.register(EventType, 'Workshop', 6, 'programming');
101Enum.register(EventType, 'AwardsCeremony', 7, 'programming');
102Enum.register(EventType, 'TableRead', 8, 'programming');
103Enum.register(EventType, 'Pitch', 9, 'programming');
104Enum.register(EventType, 'Other', 99, 'programming');
105
106
107export class InfrastructureState extends Enum {
108    static get NotProvisioned() { return Enum.forKey(InfrastructureState, 'NotProvisioned'); };
109    static get Idle() { return Enum.forKey(InfrastructureState, 'Idle'); };
110    static get Provisioning() { return Enum.forKey(InfrastructureState, 'Provisioning'); };
111    static get Running() { return Enum.forKey(InfrastructureState, 'Running'); };
112    static get Deprovisioning() { return Enum.forKey(InfrastructureState, 'Deprovisioning'); };
113    static get Error() { return Enum.forKey(InfrastructureState, 'Error'); };
114
115    static get all() {
116        return Enum.instances(InfrastructureState);
117    }
118
119    static status(code) {
120        if( isNaN(code) ) {

121            return Enum.forKey(InfrastructureState, code);
122        }
123        return Enum.forCode(InfrastructureState, code);
124    }
125
126    get selected() {
127        return this.equals(InfrastructureState.Selected);
128    }
129
130    toString() {
131        return this.name;
132    }
133}
134Enum.register(InfrastructureState, 'NotProvisioned', 0);
135Enum.register(InfrastructureState, 'Idle', 1);
136Enum.register(InfrastructureState, 'Provisioning', 2);
137Enum.register(InfrastructureState, 'Running', 3);
138Enum.register(InfrastructureState, 'Deprovisioning', 4);
139Enum.register(InfrastructureState, 'Error', 99);
140
141
142export class ScreeningPermission extends Enum {
143    static get DoNotScreen() { return Enum.forKey(ScreeningPermission, 'DoNotScreen'); };
144    static get OnlyInPerson() { return Enum.forKey(ScreeningPermission, 'OnlyInPerson'); };
145    static get OnlyOnline() { return Enum.forKey(ScreeningPermission, 'OnlyOnline'); };
146    static get Both() { return Enum.forKey(ScreeningPermission, 'Both'); };
147
148    static get all() {
149        return Enum.instances(ScreeningPermission);
150    }
151
152    static permission(code) {
153        if( isNaN(code) ) {
154            return Enum.forKey(ScreeningPermission, code);
155        }
156        return Enum.forCode(ScreeningPermission, code);
157    }
158
159    toString() {
160        return this.name;
161    }
162
163    allows(eventStyle) {
164        if( this.equals(ScreeningPermission.DoNotScreen) ) {
165            return false;
166        }
167        if( eventStyle.online ) {
168            return this.allowOnlineScreening();
169        }
170        if( eventStyle.inPerson ) {
171            return this.allowInPersonScreening();
172        }
173        return false;
174    }
175
176    allowOnlineScreening() {
177        return this.equals(ScreeningPermission.OnlyOnline) || this.equals(ScreeningPermission.Both);
178    }
179
180    allowInPersonScreening() {
181        return this.equals(ScreeningPermission.OnlyInPerson) || this.equals(ScreeningPermission.Both);
182    }
183}
184
185Enum.register(ScreeningPermission, 'DoNotScreen', 1);
186Enum.register(ScreeningPermission, 'OnlyInPerson', 2);
187Enum.register(ScreeningPermission, 'OnlyOnline', 3);
188Enum.register(ScreeningPermission, 'Both', 4);
189
190
191export class SelectionStatus extends Enum {
192    static get Unclaimed() { return Enum.forKey(SelectionStatus, 'Unclaimed'); };
193    static get Claimed() { return Enum.forKey(SelectionStatus, 'Claimed'); };
194    static get InProgress() { return Enum.forKey(SelectionStatus, 'InProgress'); };
195    static get Ready() { return Enum.forKey(SelectionStatus, 'Ready'); };
196    static get Published() { return Enum.forKey(SelectionStatus, 'Published'); };
197
198
199    static get all() {
200        return Enum.instances(SelectionStatus);
201    }
202
203    static status(code) {
204        if( isNaN(code) ) {
205            return Enum.forKey(SelectionStatus, code);
206        }
207        return Enum.forCode(SelectionStatus, code);
208    }
209
210    toString() {
211        return this.name;
212    }
213}
214Enum.register(SelectionStatus, 'Unclaimed', 0);
215Enum.register(SelectionStatus, 'Claimed', 1);
216Enum.register(SelectionStatus, 'InProgress', 2);
217Enum.register(SelectionStatus, 'Ready', 3);
218Enum.register(SelectionStatus, 'Published', 4);
219
220
221export class PremiereStatus extends Enum {
222    static get NoPremiere() { return Enum.forKey(PremiereStatus, 'NoPremiere'); };
223    static get Regional() { return Enum.forKey(PremiereStatus, 'Regional'); };
224    static get National() { return Enum.forKey(PremiereStatus, 'National'); };
225    static get Continental() { return Enum.forKey(PremiereStatus, 'Continental'); };
226    static get World() { return Enum.forKey(PremiereStatus, 'World'); };
227
228    static get all() {
229        return Enum.instances(PremiereStatus);
230    }
231
232    static status(code) {
233        if( isNaN(code) ) {
234            return Enum.forKey(PremiereStatus, code);
235        }
236        return Enum.forCode(PremiereStatus, code);
237    }
238
239    toString() {
240        return this.name;
241    }
242}
243Enum.register(PremiereStatus, 'NoPremiere', 0, 'programming');
244Enum.register(PremiereStatus, 'Regional', 1, 'programming');
245Enum.register(PremiereStatus, 'National', 2, 'programming');
246Enum.register(PremiereStatus, 'Continental', 3, 'programming');
247Enum.register(PremiereStatus, 'World', 4, 'programming');
248
249

250export class SubmissionSource extends Enum {
251    static get Sparq() { return Enum.forKey(SubmissionSource, 'Sparq'); };
252    static get FilmFreeway() { return Enum.forKey(SubmissionSource, 'FilmFreeway'); };
253    static get Festival() { return Enum.forKey(SubmissionSource, 'Festival'); };
254    static get Other() { return Enum.forKey(SubmissionSource, 'Other'); };
255
256    static get all() {
257        return Enum.instances(SubmissionSource);
258    }
259
260    static source(code) {
261        if( isNaN(code) ) {
262            return Enum.forKey(SubmissionSource, code);
263        }
264        return Enum.forCode(SubmissionSource, code);
265    }
266
267    toString() {
268        return this.name;
269    }
270}
271Enum.register(SubmissionSource, 'Sparq', 1, 'submitting');
272Enum.register(SubmissionSource, 'FilmFreeway', 2, 'submitting');
273Enum.register(SubmissionSource, 'Festival', 3, 'submitting');
274Enum.register(SubmissionSource, 'Other', 99, 'submitting');
275
276
277export class DeploymentState extends Enum {
278    static get NotProvisioned() { return Enum.forKey(DeploymentState, 'NotProvisioned'); };
279    static get WaitingForDeployment() { return Enum.forKey(DeploymentState, 'WaitingForDeployment'); };
280    static get Deploying() { return Enum.forKey(DeploymentState, 'Deploying'); };
281    static get Operational() { return Enum.forKey(DeploymentState, 'Operational'); };
282    static get WaitingForDeactivation() { return Enum.forKey(DeploymentState, 'WaitingForDeactivation'); };
283    static get Deactivated() { return Enum.forKey(DeploymentState, 'Deactivated'); };
284    static get ScheduledForDeletion() { return Enum.forKey(DeploymentState, 'ScheduledForDeletion'); };
285    static get Deleting() { return Enum.forKey(DeploymentState, 'Deleting'); };
286    static get WaitingForReactivation() { return Enum.forKey(DeploymentState, 'WaitingForReactivation'); };
287    static get Error() { return Enum.forKey(DeploymentState, 'Error'); };
288
289    static get all() {
290        return Enum.instances(DeploymentState);
291    }
292
293    static deploymentState(code) {
294        if( isNaN(code) ) {
295            return Enum.forKey(DeploymentState, code);
296        }
297        return Enum.forCode(DeploymentState, code);
298    }
299
300    toString() {
301        return this.name;
302    }
303}
304
305Enum.register(DeploymentState, 'NotProvisioned', 1, 'mgmt');
306Enum.register(DeploymentState, 'WaitingForDeployment', 2, 'mgmt');
307Enum.register(DeploymentState, 'Deploying', 3, 'mgmt');
308Enum.register(DeploymentState, 'Operational', 4, 'mgmt');
309Enum.register(DeploymentState, 'WaitingForDeactivation', 5, 'mgmt');
310Enum.register(DeploymentState, 'Deactivated', 6, 'mgmt');
311Enum.register(DeploymentState, 'ScheduledForDeletion', 7, 'mgmt');
312Enum.register(DeploymentState, 'Deleting', 8, 'mgmt');
313Enum.register(DeploymentState, 'WaitingForReactivation', 9, 'mgmt');
314Enum.register(DeploymentState, 'Error', 99, 'mgmt');
315
316
317export class SubscriptionState extends Enum {
318    static get InTrial() { return Enum.forKey(SubscriptionState, 'InTrial'); };
319    static get Active() { return Enum.forKey(SubscriptionState, 'Active'); };
320    static get InGracePeriod() { return Enum.forKey(SubscriptionState, 'InGracePeriod'); };
321    static get Expired() { return Enum.forKey(SubscriptionState, 'Expired'); };
322
323    static get all() {
324        return Enum.instances(SubscriptionState);
325    }
326
327    static subscriptionState(code) {
328        if( isNaN(code) ) {
329            return Enum.forKey(SubscriptionState, code);
330        }
331        return Enum.forCode(SubscriptionState, code);
332    }
333
334    toString() {
335        return this.name;
336    }
337}
338
339Enum.register(SubscriptionState, 'InTrial', 1, 'mgmt');
340Enum.register(SubscriptionState, 'Active', 2, 'mgmt');
341Enum.register(SubscriptionState, 'InGracePeriod', 3, 'mgmt');
342Enum.register(SubscriptionState, 'Expired', 4, 'mgmt');
343
344
345export class EntityType extends Enum {
346    static get Individual() { return Enum.forKey(EntityType, 'Individual'); }
347    static get Company() { return Enum.forKey(EntityType, 'Company'); }
348    static get NonProfit() { return Enum.forKey(EntityType, 'NonProfit'); }
349    static get USGovernment() { return Enum.forKey(EntityType, 'USGovernment'); }
350
351    static get all() {
352        return Enum.instances(AgreementType);
353    }
354
355    static entityType(code) {
356        if( isNaN(code) ) {
357            return Enum.forKey(EntityType, code);
358        }
359        return Enum.forCode(EntityType, code);
360    }
361}
362
363Enum.register(EntityType, 'Individual', 1, 'mgmt');
364Enum.register(EntityType, 'Company', 2, 'mgmt');
365Enum.register(EntityType, 'NonProfit', 3, 'mgmt');
366Enum.register(EntityType, 'USGovernment', 4, 'mgmt');